import TrsMatrix from "./TrsMatrix";
import Point3D from "./Point3D";
import {Transformable} from "./types";
import MatrixFour from "./MatrixFour";

class Camera implements Transformable {
    private trs: TrsMatrix;
    constructor();
    constructor(position: Point3D, lookAt: Point3D, up: Point3D);
    constructor(radius: number, rotX: number, rotY: number, rotZ: number);
    constructor(...args: any[]) {
        this.trs = new TrsMatrix();
        if (args[0] !== undefined) {
            if (args[0] instanceof Point3D) {
                this.trs.setPosition(args[0]);
                this.lookAt(args[1], args[2]);
            }
            else {
                this.rotateBy(args[1], args[2], args[3]);
                this.translateBy(0, 0, args[0]);
            }
        }
    }

    translateBy(tX: number, tY: number, tZ: number): Camera {
        this.trs.translateBy(tX, tY, tZ);
        return this;
    }

    rotateBy(degX: number, degY: number, degZ: number): Camera {
        this.trs.rotateBy(degX, degY, degZ);
        return this;
    }

    scaleBy(sX: number, sY: number, sZ: number): Camera {
        this.trs.scaleBy(sX, sY, sZ);
        return this;
    }

    getTrsMatrix(): TrsMatrix {
        return this.trs;
    }

    position(): Point3D {
        return this.trs.position();
    };

    lookAt(other: Point3D, up: Point3D) {
        const selfPosition = this.position();
        const zAxis = selfPosition.minus(other).normalised();
        const xAxis = up.cross(zAxis).normalised();
        const yAxis = zAxis.cross(xAxis).normalised();
        this.trs.setSlice([
            xAxis.x(), xAxis.y(), xAxis.z(), 0,
            yAxis.x(), yAxis.y(), yAxis.z(), 0,
            zAxis.x(), zAxis.y(), zAxis.z(), 0,
            selfPosition.x(), selfPosition.y(), selfPosition.z(), 1,
        ], 0);
    }

    viewMat(): MatrixFour {
        return this.trs.inverse();
    }
}

export default Camera;