import { action, computed, observable } from "mobx";
import { Doc, Field, Opt } from "../../fields/Doc";
import { Document } from "../../fields/documentSchemas";
import { InkField, InkData, PointData } from "../../fields/InkField";
import { Cast, NumCast } from "../../fields/Types";
import { DocumentType } from "../documents/DocumentTypes";
import { SelectionManager } from "../util/SelectionManager";
import { undoBatch } from "../util/UndoManager";

export class InkStrokeProperties {
    static Instance: InkStrokeProperties | undefined;

    @observable _lock = false;
    @observable _controlButton = false;
    @observable _currentPoint = -1;

    constructor() {
        InkStrokeProperties.Instance = this;
    }

    @computed get selectedInk() {
        const inks = SelectionManager.Views().filter(i => Document(i.rootDoc).type === DocumentType.INK);
        return inks.length ? inks : undefined;
    }

    getField(key: string) {
        return this.selectedInk?.reduce((p, i) =>
            (p === undefined || (p && p === i.rootDoc[key])) && i.rootDoc[key] !== "0" ? Field.toString(i.rootDoc[key] as Field) : "", undefined as Opt<string>);
    }

    /**
     * Helper function that enables other functions to be applied to a particular ink instance.
     * @param func The inputted function.
     * @param requireCurrPoint Indicates whether the current selected point is needed.
     */
     applyFunction = (func: (doc: Doc, ink: InkData, ptsXscale: number, ptsYscale: number) => { X: number, Y: number }[] | undefined, requireCurrPoint: boolean = false) => {
        var appliedFunc = false;
        this.selectedInk?.forEach(action(inkView => {
            if (this.selectedInk?.length === 1 && (!requireCurrPoint || this._currentPoint !== -1)) {
                const doc = Document(inkView.rootDoc);
                if (doc.type === DocumentType.INK && doc.width && doc.height) {
                    const ink = Cast(doc.data, InkField)?.inkData;
                    if (ink) {
                        const oldXrange = (xs => ({ coord: NumCast(doc.x), min: Math.min(...xs), max: Math.max(...xs) }))(ink.map(p => p.X));
                        const oldYrange = (ys => ({ coord: NumCast(doc.y), min: Math.min(...ys), max: Math.max(...ys) }))(ink.map(p => p.Y));
                        const ptsXscale = NumCast(doc._width) / (oldXrange.max - oldXrange.min);
                        const ptsYscale = NumCast(doc._height) / (oldYrange.max - oldYrange.min);
                        const newPoints = func(doc, ink, ptsXscale, ptsYscale);
                        if (newPoints) {
                            const newXrange = (xs => ({ min: Math.min(...xs), max: Math.max(...xs) }))(newPoints.map(p => p.X));
                            const newYrange = (ys => ({ min: Math.min(...ys), max: Math.max(...ys) }))(newPoints.map(p => p.Y));
                            doc._width = (newXrange.max - newXrange.min) * ptsXscale;
                            doc._height = (newYrange.max - newYrange.min) * ptsYscale;
                            doc.x = (oldXrange.coord + (newXrange.min - oldXrange.min) * ptsXscale);
                            doc.y = (oldYrange.coord + (newYrange.min - oldYrange.min) * ptsYscale);
                            Doc.GetProto(doc).data = new InkField(newPoints);
                            appliedFunc = true;
                        }
                    }
                }
            }
        }));
        return appliedFunc;
    }

    /**
     * Adds a new control point to the ink instance when editing its format.
     * @param index The index of the new point.
     * @param control The list of all control points of the ink.
     */
    @undoBatch
    @action
    addPoints = (x: number, y: number, pts: { X: number, Y: number }[], index: number, control: { X: number, Y: number }[]) => {
        this.selectedInk?.forEach(action(inkView => {
            if (this.selectedInk?.length === 1) {
                const doc = Document(inkView.rootDoc);
                if (doc.type === DocumentType.INK) {
                    const ink = Cast(doc.data, InkField)?.inkData;
                    if (ink) {
                        const newPoints: { X: number, Y: number }[] = [];
                        var counter = 0;
                        for (var k = 0; k < index; k++) {
                            control.forEach(pt => (pts[k].X === pt.X && pts[k].Y === pt.Y) && counter++);
                        }
                        //decide where to put the new coordinate
                        const spNum = Math.floor(counter / 2) * 4 + 2;

                        for (var i = 0; i < spNum; i++) {
                            ink[i] && newPoints.push({ X: ink[i].X, Y: ink[i].Y });
                        }
                        for (var j = 0; j < 4; j++) {
                            newPoints.push({ X: x, Y: y });

                        }
                        for (var i = spNum; i < ink.length; i++) {
                            newPoints.push({ X: ink[i].X, Y: ink[i].Y });
                        }
                        this._currentPoint = -1;
                        Doc.GetProto(doc).data = new InkField(newPoints);
                    }
                }
            }
        }));
    }

    /**
     * Deletes the points of the current ink instance.
     * @returns The changed x- and y-coordinates of the control points.
     */
    @undoBatch
    @action
    deletePoints = () => this.applyFunction((doc: Doc, ink: InkData) => {
        const newPoints: { X: number, Y: number }[] = [];
        const toRemove = Math.floor(((this._currentPoint + 2) / 4));
        for (let i = 0; i < ink.length; i++) {
            if (Math.floor((i + 2) / 4) !== toRemove && (toRemove !== 0 || i > 3)) {
                newPoints.push({ X: ink[i].X, Y: ink[i].Y });
            }
        }
        this._currentPoint = -1;
        if (newPoints.length < 4) return undefined;
        if (newPoints.length === 4) {
            const newerPoints: { X: number, Y: number }[] = [];
            newerPoints.push({ X: newPoints[0].X, Y: newPoints[0].Y });
            newerPoints.push({ X: newPoints[0].X, Y: newPoints[0].Y });
            newerPoints.push({ X: newPoints[3].X, Y: newPoints[3].Y });
            newerPoints.push({ X: newPoints[3].X, Y: newPoints[3].Y });
            return newerPoints;
        }
        return newPoints;
    }, true)

    /**
     * Rotates the points of the current ink instance by a certain angle degree.
     * @param angle The angle at which to rotate the ink (all of its x- and y-coordinates).
     * @returns The changed x- and y-coordinates of the control points.
     */
    @undoBatch
    @action
    rotateInk = (angle: number) => {
        this.applyFunction((doc: Doc, ink: InkData, xScale: number, yScale: number) => {
            const oldXrange = (xs => ({ coord: NumCast(doc.x), min: Math.min(...xs), max: Math.max(...xs) }))(ink.map(p => p.X));
            const oldYrange = (ys => ({ coord: NumCast(doc.y), min: Math.min(...ys), max: Math.max(...ys) }))(ink.map(p => p.Y));
            const centerPoint = { X: (oldXrange.min + oldXrange.max) / 2, Y: (oldYrange.min + oldYrange.max) / 2 };
            const newPoints: { X: number, Y: number }[] = [];
            ink.map(i => ({ X: i.X - centerPoint.X, Y: i.Y - centerPoint.Y })).forEach(i => {
                const newX = Math.cos(angle) * i.X - Math.sin(angle) * i.Y;
                const newY = Math.sin(angle) * i.X + Math.cos(angle) * i.Y;
                newPoints.push({ X: newX + centerPoint.X, Y: newY + centerPoint.Y });
            });
            doc.rotation = NumCast(doc.rotation) + angle;
            return newPoints;
        });
    }

    /**
     * Handles the movement/scaling of a control point.
     */
    @undoBatch
    @action
    moveControl = (deltaX: number, deltaY: number, controlIndex: number) =>
        this.applyFunction((doc: Doc, ink: InkData, xScale: number, yScale: number) => {
            const newPoints: { X: number, Y: number }[] = [];
            const order = controlIndex % 4;
            for (var i = 0; i < ink.length; i++) {
                const leftHandlePoint = order === 0 && i === controlIndex + 1;
                const rightHandlePoint = order === 0 && controlIndex !== 0 && i === controlIndex - 2;
                if (controlIndex === i ||
                    leftHandlePoint ||
                    rightHandlePoint ||
                    (order === 0 && controlIndex !== 0 && i === controlIndex - 1) ||
                    (order === 3 && i === controlIndex - 1) ||
                    (order === 3 && controlIndex !== ink.length - 1 && i === controlIndex + 1) ||
                    (order === 3 && controlIndex !== ink.length - 1 && i === controlIndex + 2) ||
                    ((ink[0].X === ink[ink.length - 1].X) && (ink[0].Y === ink[ink.length - 1].Y) && (i === 0 || i === ink.length - 1) && (controlIndex === 0 || controlIndex === ink.length - 1))) {
                    newPoints.push({ X: ink[i].X - deltaX / xScale, Y: ink[i].Y - deltaY / yScale });
                } else {
                    newPoints.push({ X: ink[i].X, Y: ink[i].Y });
                }
            }
            return newPoints;
        })

    /**
     * Rotates the target point about the origin point for a given angle (radians).
     */
    @action
    rotatePoint = (target: PointData, origin: PointData, angle: number) => {
        target.X -= origin.X;
        target.Y -= origin.Y;
        const newX = Math.cos(angle) * target.X - Math.sin(angle) * target.Y;
        const newY = Math.sin(angle) * target.X + Math.cos(angle) * target.Y;
        target.X = newX + origin.X;
        target.Y = newY + origin.Y;
        return target;
    }

    /**
     * Finds the angle difference (in radians) between two vectors relative to an arbitrary origin.
     */
    angleChange = (a: PointData, b: PointData, origin: PointData) => {
        // Finding vector representation of inputted points relative to new origin.
        let vectorA = { X: a.X - origin.X, Y: a.Y - origin.Y };
        let vectorB = { X: b.X - origin.X, Y: b.Y - origin.Y };
        const crossProduct = vectorB.X * vectorA.Y - vectorB.Y * vectorA.X;
        // Determining whether rotation is clockwise or counterclockwise.
        const sign = crossProduct < 0 ? 1 : -1;
        const magnitudeA = Math.sqrt(vectorA.X * vectorA.X + vectorA.Y * vectorA.Y);
        const magnitudeB = Math.sqrt(vectorB.X * vectorB.X + vectorB.Y * vectorB.Y);
        // Normalizing the vectors.
        vectorA = { X: vectorA.X / magnitudeA, Y: vectorA.Y / magnitudeA };
        vectorB = { X: vectorB.X / magnitudeB, Y: vectorB.Y / magnitudeB };
        const dotProduct = vectorB.X * vectorA.X + vectorB.Y * vectorA.Y;
        const theta = Math.acos(dotProduct);
        return sign * theta;
    }

    /**
     * Handles the movement/scaling of a handle point.
     */
    @undoBatch
    @action
    moveHandle = (deltaX: number, deltaY: number, handleIndex: number) =>
        this.applyFunction((doc: Doc, ink: InkData, xScale: number, yScale: number) => {
            const order = handleIndex % 4;
            const oldHandlePoint = ink[handleIndex];
            const newHandlePoint = { X: ink[handleIndex].X - deltaX / xScale, Y: ink[handleIndex].Y - deltaY / yScale };
            ink[handleIndex] = newHandlePoint;
            
            // Rotating opposite handle (first and final control point only have one handle).
            if (handleIndex !== 1 && handleIndex !== ink.length - 2) {
                let oppositeHandlePoint = order === 1 ? ink[handleIndex - 3] : ink[handleIndex + 3];
                const controlPoint = order === 1 ? ink[handleIndex - 1] : ink[handleIndex + 1];
                const angle = this.angleChange(oldHandlePoint, newHandlePoint, controlPoint);
                oppositeHandlePoint = this.rotatePoint(oppositeHandlePoint, controlPoint, angle);
                order === 1 ? ink[handleIndex - 3] = oppositeHandlePoint : ink[handleIndex + 3] = oppositeHandlePoint;
            }

            return ink;
        })
}