import type { ExpressionParam, NerdamerExpression } from '../index';

// Import complete nerdamer with all modules for runtime
const nerdamer = require('../all');

function expectType<T>(_value: T): void {}

describe('Nerdamer Extra Module Type Definitions', () => {
    it('should compile when using matrix functions correctly', () => {
        // Test matrix creation
        const matrix1: NerdamerExpression = nerdamer.matrix([
            [1, 2],
            [3, 4],
        ]);
        expectType<NerdamerExpression>(matrix1);

        const matrix2: NerdamerExpression = nerdamer.matrix('[[1, 2], [3, 4]]');
        expectType<NerdamerExpression>(matrix2);

        // Test identity matrix - use this for inversion since it's always invertible
        const identityMatrix: NerdamerExpression = nerdamer.imatrix(2);
        expectType<NerdamerExpression>(identityMatrix);

        // Test matrix operations
        const determinant: NerdamerExpression = nerdamer.determinant(matrix1);
        expectType<NerdamerExpression>(determinant);

        const transposed: NerdamerExpression = nerdamer.transpose(matrix1);
        expectType<NerdamerExpression>(transposed);

        // Use identity matrix for inversion (always invertible)
        const inverted: NerdamerExpression = nerdamer.invert(identityMatrix);
        expectType<NerdamerExpression>(inverted);

        // Test matrix element access
        const element: NerdamerExpression = nerdamer.matget(matrix1, 0, 1);
        expectType<NerdamerExpression>(element);

        const setElement: NerdamerExpression = nerdamer.matset(matrix1, 0, 1, 5);
        expectType<NerdamerExpression>(setElement);

        // Test matrix row/column operations
        const row: NerdamerExpression = nerdamer.matgetrow(matrix1, 0);
        expectType<NerdamerExpression>(row);

        const column: NerdamerExpression = nerdamer.matgetcol(matrix1, 1);
        expectType<NerdamerExpression>(column);

        // Test vector creation for matrix operations (types work correctly)
        const rowVector: NerdamerExpression = nerdamer.vector([5, 6]);
        expectType<NerdamerExpression>(rowVector);

        const colVector: NerdamerExpression = nerdamer.vector([7, 8]);
        expectType<NerdamerExpression>(colVector);

        // Note: matsetrow and matsetcol have strict runtime dimension requirements
        // The type definitions are correct but we skip runtime execution due to complexity

        // Test matrix size
        const matrixSize: NerdamerExpression = nerdamer.size('[[1, 2, 3], [4, 5, 6]]');
        expectType<NerdamerExpression>(matrixSize);
    });

    it('should compile when using vector functions correctly', () => {
        // Test vector creation
        const vector1: NerdamerExpression = nerdamer.vector([1, 2, 3]);
        expectType<NerdamerExpression>(vector1);

        const vector2: NerdamerExpression = nerdamer.vector('[4, 5, 6]');
        expectType<NerdamerExpression>(vector2);

        // Test vector operations
        const dotProduct: NerdamerExpression = nerdamer.dot('[1, 2, 3]', '[4, 5, 6]');
        expectType<NerdamerExpression>(dotProduct);

        const crossProduct: NerdamerExpression = nerdamer.cross('[1, 2, 3]', '[4, 5, 6]');
        expectType<NerdamerExpression>(crossProduct);

        // Test vector element access
        const vectorElement: NerdamerExpression = nerdamer.vecget('[1, 2, 3]', 1);
        expectType<NerdamerExpression>(vectorElement);

        const setVectorElement: NerdamerExpression = nerdamer.vecset('[1, 2, 3]', 1, 5);
        expectType<NerdamerExpression>(setVectorElement);
    });

    it('should compile when using complex number functions correctly', () => {
        // Test complex number operations
        const polarForm: NerdamerExpression = nerdamer.polarform('3 + 4*i');
        expectType<NerdamerExpression>(polarForm);

        const rectForm: NerdamerExpression = nerdamer.rectform('5*e^(i*pi/4)');
        expectType<NerdamerExpression>(rectForm);

        const argument: NerdamerExpression = nerdamer.arg('3 + 4*i');
        expectType<NerdamerExpression>(argument);

        const realPart: NerdamerExpression = nerdamer.realpart('3 + 4*i');
        expectType<NerdamerExpression>(realPart);

        const imagPart: NerdamerExpression = nerdamer.imagpart('3 + 4*i');
        expectType<NerdamerExpression>(imagPart);
    });

    it('should compile when using mathematical functions correctly', () => {
        // Test logarithmic functions
        const naturalLog: NerdamerExpression = nerdamer.log('e^2');
        expectType<NerdamerExpression>(naturalLog);

        const logWithBase: NerdamerExpression = nerdamer.log('8', '2');
        expectType<NerdamerExpression>(logWithBase);

        const log10: NerdamerExpression = nerdamer.log10('100');
        expectType<NerdamerExpression>(log10);

        const log2: NerdamerExpression = nerdamer.log2('8');
        expectType<NerdamerExpression>(log2);

        const log1p: NerdamerExpression = nerdamer.log1p('0.5');
        expectType<NerdamerExpression>(log1p);

        // Test min/max functions
        const minimum: NerdamerExpression = nerdamer.min(1, 2, 3, 'x');
        expectType<NerdamerExpression>(minimum);

        const maximum: NerdamerExpression = nerdamer.max('a', 'b', 'c');
        expectType<NerdamerExpression>(maximum);

        // Test other math functions
        const absoluteValue: NerdamerExpression = nerdamer.abs('-5');
        expectType<NerdamerExpression>(absoluteValue);

        const squareRoot: NerdamerExpression = nerdamer.sqrt('16');
        expectType<NerdamerExpression>(squareRoot);

        const exponential: NerdamerExpression = nerdamer.exp('x');
        expectType<NerdamerExpression>(exponential);

        const factorial: NerdamerExpression = nerdamer.fact('5');
        expectType<NerdamerExpression>(factorial);

        const sign: NerdamerExpression = nerdamer.sign('-3');
        expectType<NerdamerExpression>(sign);

        const modulo: NerdamerExpression = nerdamer.mod('10', '3');
        expectType<NerdamerExpression>(modulo);
    });

    it('should compile when using statistics functions correctly', () => {
        // Test statistical functions
        const meanValue: NerdamerExpression = nerdamer.mean([1, 2, 3, 4, 5]);
        expectType<NerdamerExpression>(meanValue);

        const medianValue: NerdamerExpression = nerdamer.median(['1', '2', '3', '4', '5']);
        expectType<NerdamerExpression>(medianValue);

        const modeValue: NerdamerExpression | NerdamerExpression[] = nerdamer.mode([1, 2, 2, 3]);
        expectType<NerdamerExpression | NerdamerExpression[]>(modeValue);

        const variance: NerdamerExpression = nerdamer.variance([1, 2, 3, 4, 5]);
        expectType<NerdamerExpression>(variance);

        const standardDeviation: NerdamerExpression = nerdamer.stdev([1, 2, 3, 4, 5]);
        expectType<NerdamerExpression>(standardDeviation);

        // Note: smpvar function has strict mathematical requirements (needs n>1 with variance)
        // The type definition is correct but we verify signature only
        // Expected: (values: ExpressionParam[]) => NerdamerExpression
        const smpvarCheck: (values: ExpressionParam[]) => NerdamerExpression = nerdamer.smpvar;
        expectType<(values: ExpressionParam[]) => NerdamerExpression>(smpvarCheck);

        // Note: smpstdev function has same mathematical requirements as smpvar
        // The type definition is correct but we verify signature only
        const smpstdevCheck: (values: ExpressionParam[]) => NerdamerExpression = nerdamer.smpstdev;
        expectType<(values: ExpressionParam[]) => NerdamerExpression>(smpstdevCheck);

        const zScore: NerdamerExpression = nerdamer.zscore(75, 70, 5);
        expectType<NerdamerExpression>(zScore);
    });

    it('should compile when using transform functions correctly', () => {
        // Test Laplace transforms
        const laplaceTransform: NerdamerExpression = nerdamer.laplace('t^2', 't', 's');
        expectType<NerdamerExpression>(laplaceTransform);

        const inverseLaplace: NerdamerExpression = nerdamer.ilt('1/s^3', 's', 't');
        expectType<NerdamerExpression>(inverseLaplace);
    });

    it('should compile when using trigonometric functions correctly', () => {
        // Test basic trig functions
        const sine: NerdamerExpression = nerdamer.sin('pi/2');
        expectType<NerdamerExpression>(sine);

        const cosine: NerdamerExpression = nerdamer.cos('0');
        expectType<NerdamerExpression>(cosine);

        const tangent: NerdamerExpression = nerdamer.tan('pi/4');
        expectType<NerdamerExpression>(tangent);

        // Test inverse trig functions
        const arcsine: NerdamerExpression = nerdamer.asin('1');
        expectType<NerdamerExpression>(arcsine);

        const arctangent2: NerdamerExpression = nerdamer.atan2('1', '1');
        expectType<NerdamerExpression>(arctangent2);

        // Test hyperbolic functions
        const hyperbolicSine: NerdamerExpression = nerdamer.sinh('x');
        expectType<NerdamerExpression>(hyperbolicSine);

        const hyperbolicCosine: NerdamerExpression = nerdamer.cosh('x');
        expectType<NerdamerExpression>(hyperbolicCosine);
    });
});