import PathProxy from '../../core/PathProxy';
import { isArray } from '../../core/util';

const PI = Math.PI;
const PI2 = PI * 2;
const mathSin = Math.sin;
const mathCos = Math.cos;
const mathACos = Math.acos;
const mathATan2 = Math.atan2;
const mathAbs = Math.abs;
const mathSqrt = Math.sqrt;
const mathMax = Math.max;
const mathMin = Math.min;
const e = 1e-4;

function intersect(
    x0: number, y0: number,
    x1: number, y1: number,
    x2: number, y2: number,
    x3: number, y3: number
): [number, number] {
    const dx10 = x1 - x0;
    const dy10 = y1 - y0;
    const dx32 = x3 - x2;
    const dy32 = y3 - y2;
    let t = dy32 * dx10 - dx32 * dy10;
    if (t * t < e) {
        return;
    }
    t = (dx32 * (y0 - y2) - dy32 * (x0 - x2)) / t;
    return [x0 + t * dx10, y0 + t * dy10];
}

// Compute perpendicular offset line of length rc.
function computeCornerTangents(
    x0: number, y0: number,
    x1: number, y1: number,
    radius: number, cr: number,
    clockwise: boolean
) {
    const x01 = x0 - x1;
    const y01 = y0 - y1;
    const lo = (clockwise ? cr : -cr) / mathSqrt(x01 * x01 + y01 * y01);
    const ox = lo * y01;
    const oy = -lo * x01;
    const x11 = x0 + ox;
    const y11 = y0 + oy;
    const x10 = x1 + ox;
    const y10 = y1 + oy;
    const x00 = (x11 + x10) / 2;
    const y00 = (y11 + y10) / 2;
    const dx = x10 - x11;
    const dy = y10 - y11;
    const d2 = dx * dx + dy * dy;
    const r = radius - cr;
    const s = x11 * y10 - x10 * y11;
    const d = (dy < 0 ? -1 : 1) * mathSqrt(mathMax(0, r * r * d2 - s * s));
    let cx0 = (s * dy - dx * d) / d2;
    let cy0 = (-s * dx - dy * d) / d2;
    const cx1 = (s * dy + dx * d) / d2;
    const cy1 = (-s * dx + dy * d) / d2;
    const dx0 = cx0 - x00;
    const dy0 = cy0 - y00;
    const dx1 = cx1 - x00;
    const dy1 = cy1 - y00;

    // Pick the closer of the two intersection points
    // TODO: Is there a faster way to determine which intersection to use?
    if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) {
        cx0 = cx1;
        cy0 = cy1;
    }

    return {
        cx: cx0,
        cy: cy0,
        x0: -ox,
        y0: -oy,
        x1: cx0 * (radius / r - 1),
        y1: cy0 * (radius / r - 1)
    };
}

// For compatibility, don't use normalizeCssArray
// 5 represents [5, 5, 5, 5]
// [5] represents [5, 5, 0, 0]
// [5, 10] represents [5, 5, 10, 10]
// [5, 10, 15] represents [5, 10, 15, 15]
// [5, 10, 15, 20] represents [5, 10, 15, 20]
function normalizeCornerRadius(cr: number | number[]): number[] {
    let arr: number[];
    if (isArray(cr)) {
        const len = cr.length;
        if (!len) {
            return cr as number[];
        }
        if (len === 1) {
            arr = [cr[0], cr[0], 0, 0];
        }
        else if (len === 2) {
            arr = [cr[0], cr[0], cr[1], cr[1]];
        }
        else if (len === 3) {
            arr = cr.concat(cr[2]);
        }
        else {
            arr = cr;
        }
    }
    else {
        arr = [cr, cr, cr, cr];
    }
    return arr;
}

export function buildPath(ctx: CanvasRenderingContext2D | PathProxy, shape: {
    cx: number
    cy: number
    startAngle: number
    endAngle: number
    clockwise?: boolean,
    r?: number,
    r0?: number,
    cornerRadius?: number | number[]
}) {
    let radius = mathMax(shape.r, 0);
    let innerRadius = mathMax(shape.r0 || 0, 0);
    const hasRadius = radius > 0;
    const hasInnerRadius = innerRadius > 0;

    if (!hasRadius && !hasInnerRadius) {
        return;
    }

    if (!hasRadius) {
        // use innerRadius as radius if no radius
        radius = innerRadius;
        innerRadius = 0;
    }

    if (innerRadius > radius) {
        // swap, ensure that radius is always larger than innerRadius
        const tmp = radius;
        radius = innerRadius;
        innerRadius = tmp;
    }

    const { startAngle, endAngle } = shape;
    if (isNaN(startAngle) || isNaN(endAngle)) {
        return;
    }

    const { cx, cy } = shape;
    const clockwise = !!shape.clockwise;

    let arc = mathAbs(endAngle - startAngle);
    const mod = arc > PI2 && arc % PI2;
    mod > e && (arc = mod);

    // is a point
    if (!(radius > e)) {
        ctx.moveTo(cx, cy);
    }
    // is a circle or annulus
    else if (arc > PI2 - e) {
        ctx.moveTo(
            cx + radius * mathCos(startAngle),
            cy + radius * mathSin(startAngle)
        );
        ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise);

        if (innerRadius > e) {
            ctx.moveTo(
                cx + innerRadius * mathCos(endAngle),
                cy + innerRadius * mathSin(endAngle)
            );
            ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
        }
    }
    // is a circular or annular sector
    else {
        let icrStart;
        let icrEnd;
        let ocrStart;
        let ocrEnd;

        let ocrs;
        let ocre;
        let icrs;
        let icre;

        let ocrMax;
        let icrMax;
        let limitedOcrMax;
        let limitedIcrMax;

        let xre;
        let yre;
        let xirs;
        let yirs;

        const xrs = radius * mathCos(startAngle);
        const yrs = radius * mathSin(startAngle);
        const xire = innerRadius * mathCos(endAngle);
        const yire = innerRadius * mathSin(endAngle);

        const hasArc = arc > e;
        if (hasArc) {
            const cornerRadius = shape.cornerRadius;
            if (cornerRadius) {
                [icrStart, icrEnd, ocrStart, ocrEnd] = normalizeCornerRadius(cornerRadius);
            }

            const halfRd = mathAbs(radius - innerRadius) / 2;
            ocrs = mathMin(halfRd, ocrStart);
            ocre = mathMin(halfRd, ocrEnd);
            icrs = mathMin(halfRd, icrStart);
            icre = mathMin(halfRd, icrEnd);

            limitedOcrMax = ocrMax = mathMax(ocrs, ocre);
            limitedIcrMax = icrMax = mathMax(icrs, icre);

            // draw corner radius
            if (ocrMax > e || icrMax > e) {
                xre = radius * mathCos(endAngle);
                yre = radius * mathSin(endAngle);
                xirs = innerRadius * mathCos(startAngle);
                yirs = innerRadius * mathSin(startAngle);

                // restrict the max value of corner radius
                if (arc < PI) {
                    const it = intersect(xrs, yrs, xirs, yirs, xre, yre, xire, yire);
                    if (it) {
                        const x0 = xrs - it[0];
                        const y0 = yrs - it[1];
                        const x1 = xre - it[0];
                        const y1 = yre - it[1];
                        const a = 1 / mathSin(
                            // eslint-disable-next-line max-len
                            mathACos((x0 * x1 + y0 * y1) / (mathSqrt(x0 * x0 + y0 * y0) * mathSqrt(x1 * x1 + y1 * y1))) / 2
                        );
                        const b = mathSqrt(it[0] * it[0] + it[1] * it[1]);
                        limitedOcrMax = mathMin(ocrMax, (radius - b) / (a + 1));
                        limitedIcrMax = mathMin(icrMax, (innerRadius - b) / (a - 1));
                    }
                }
            }
        }

        // the sector is collapsed to a line
        if (!hasArc) {
            ctx.moveTo(cx + xrs, cy + yrs);
        }
        // the outer ring has corners
        else if (limitedOcrMax > e) {
            const crStart = mathMin(ocrStart, limitedOcrMax);
            const crEnd = mathMin(ocrEnd, limitedOcrMax);
            const ct0 = computeCornerTangents(xirs, yirs, xrs, yrs, radius, crStart, clockwise);
            const ct1 = computeCornerTangents(xre, yre, xire, yire, radius, crEnd, clockwise);

            ctx.moveTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);

            // Have the corners merged?
            if (limitedOcrMax < ocrMax && crStart === crEnd) {
                // eslint-disable-next-line max-len
                ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedOcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
            }
            else {
                // draw the two corners and the ring
                // eslint-disable-next-line max-len
                crStart > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crStart, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
                // eslint-disable-next-line max-len
                ctx.arc(cx, cy, radius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), !clockwise);
                // eslint-disable-next-line max-len
                crEnd > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crEnd, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
            }
        }
        // the outer ring is a circular arc
        else {
            ctx.moveTo(cx + xrs, cy + yrs);
            ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
        }

        // no inner ring, is a circular sector
        if (!(innerRadius > e) || !hasArc) {
            ctx.lineTo(cx + xire, cy + yire);
        }
        // the inner ring has corners
        else if (limitedIcrMax > e) {
            const crStart = mathMin(icrStart, limitedIcrMax);
            const crEnd = mathMin(icrEnd, limitedIcrMax);
            const ct0 = computeCornerTangents(xire, yire, xre, yre, innerRadius, -crEnd, clockwise);
            const ct1 = computeCornerTangents(xrs, yrs, xirs, yirs, innerRadius, -crStart, clockwise);
            ctx.lineTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);

            // Have the corners merged?
            if (limitedIcrMax < icrMax && crStart === crEnd) {
                // eslint-disable-next-line max-len
                ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedIcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
            }
            // draw the two corners and the ring
            else {
                // eslint-disable-next-line max-len
                crEnd > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crEnd, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
                // eslint-disable-next-line max-len
                ctx.arc(cx, cy, innerRadius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), clockwise);
                // eslint-disable-next-line max-len
                crStart > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crStart, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
            }
        }
        // the inner ring is just a circular arc
        else {
            // FIXME: if no lineTo, svg renderer will perform an abnormal drawing behavior.
            ctx.lineTo(cx + xire, cy + yire);

            ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
        }
    }

    ctx.closePath();
}