export const ARROW_BODY_STYLE_CONSTANT = 1;
export const ARROW_BODY_STYLE_LINEAR = 2;
export const ARROW_BODY_STYLE_EXPONENTIAL = 3;

const distancePerDegreeLongitude = 111.320; // 2π×6378.1km/360
const distancePerDegreeLatitude  = 110.574; // 2π×6356.75km/360

import * as turf from "@turf/turf";



function round(value, decimals = 6) {
    return Number(value.toFixed(decimals));
}

// Převod z lon/lat do Web Mercator (v metrech)
function lonLatToMeters(lon, lat) {
    const originShift = 2 * Math.PI * 6378137 / 2.0;
    const mx = lon * originShift / 180.0 ;
    const my = Math.log(Math.tan((90 + lat) * Math.PI / 360.0)) / (Math.PI / 180.0)* 150;

    //console.log(JSON.stringify(mx, null, 2));

    return {
        x: mx,
        y: my * originShift / 180.0
    };
}

// Převod z Web Mercator zpět do lon/lat
function metersToLonLat(mx, my) {
    const originShift = 2 * Math.PI * 6378137 / 2.0;
    const lon = (mx / originShift) * 180.0;
    const lat = 180 / Math.PI * (2 * Math.atan(Math.exp(my / originShift * Math.PI / 180.0)) - Math.PI / 2);

    return {
        lon: round(lon, 6),
        lat: round(lat, 6)
    };
}

/**
 * @param {Object} arrowData - Object with data for arrow
 * @param {{x: number, y: number}[]} arrowData.points - List of points defining the arrow's path.
 * @param {number} arrowData.splineStep - The step size for the spline interpolation.
 * @param {number} arrowData.spacing - The spacing between the points along the arrow.
 * @param {number} arrowData.offsetDistance - The offset distance for the arrow's path (width).
 * 
 * @param {Object} style - Object with data for the calculation style.
 * @param {number} style.calculation - The style for the calculation
 * @param {number} style.range - The range for the calculation style.
 * @param {number} style.minValue - The minimum value used in the calculation.
 * 
 * @param {Object|undefined} arrowHeadData - Optional data for the arrowhead.
 * @param {number} arrowHeadData.widthArrow - The width of the arrowhead.
 * @param {number} arrowHeadData.lengthArrow - The length of the arrowhead.
 * 
 * @returns {{x: number, y: number}[]} - An array of points representing the arrow polygon.
 */
export function getArrowPolygon(
    arrowData,
    style= undefined,
    arrowHeadData = undefined) {

    if (!style)
        style = {
            calculation: ARROW_BODY_STYLE_CONSTANT,
            range: 0,
            minValue: 0
        };

    const splinePoints = computeSplinePoints(arrowData.points, arrowData.splineStep);
    const { leftSidePoints, rightSidePoints }  = computeSides(splinePoints, arrowData.spacing, arrowData.offsetDistance, style);
    const arrowHead= arrowHeadData
    ? createIsoscelesTriangleFromSpline(splinePoints, arrowHeadData.widthArrow, arrowHeadData.lengthArrow)
    : [];
    
    const fullPolygon = [...leftSidePoints, ...arrowHead.reverse(), ...rightSidePoints.reverse()];
    return fullPolygon;
}

function computeSplinePoints(points, splineStep) {
    let splinePoints = [];

    for (let i = 0; i < points.length - 1; i++) {
        const p0 = points[i === 0 ? i : i - 1];
        const p1 = points[i];
        const p2 = points[i + 1];
        const p3 = points[i + 2] || p2;
        for (let t = 0; t <= 1; t += splineStep) {
            splinePoints.push({
                x: cubicInterpolate([p0.x, p1.x, p2.x, p3.x], t),
                y: cubicInterpolate([p0.y, p1.y, p2.y, p3.y], t)
            });
        }
    }
    splinePoints.x /100;
    return splinePoints;
}

function computeSides(splinePoints, spacing, offsetDistance, style) {

    let leftSidePoints = [];
    let rightSidePoints = [];
    let accumulatedDistance = 0;

    for (let i = 1; i < splinePoints.length; i++) {
        const previousPoint = splinePoints[i - 1];
        const currentPoint = splinePoints[i];
        const segmentLength = Math.hypot(currentPoint.x - previousPoint.x, currentPoint.y - previousPoint.y);

        accumulatedDistance += segmentLength;

        if (accumulatedDistance >= spacing || i === 1 || i === splinePoints.length - 1) {
            let distanceX;
            let distanceY;
            if (i == 1 || i == splinePoints.length-1)
            {
                distanceX = (currentPoint.y - previousPoint.y);
                distanceY = (previousPoint.x - currentPoint.x);
            }else
            {
                distanceX = (currentPoint.y - previousPoint.y) ;
                distanceY = (previousPoint.x - currentPoint.x) ;
            }
            const length = Math.hypot(distanceX, distanceY);
            const normalizedPosition = i / (splinePoints.length - 1);
            
            let localOffsetDistance;

            switch (style.calculation) {
                case ARROW_BODY_STYLE_LINEAR:
                    localOffsetDistance = offsetDistance * linearWidthCurve(normalizedPosition, style.range, style.minValue);
                    break;
                case ARROW_BODY_STYLE_EXPONENTIAL:
                    localOffsetDistance = offsetDistance * exponentialWidthCurve(normalizedPosition, style.range, style.minValue);
                    break;
                case ARROW_BODY_STYLE_CONSTANT:
                default:
                    localOffsetDistance = offsetDistance;
            }

            const offsetX = (distanceX / length) * localOffsetDistance;
            const offsetY = (distanceY / length) * localOffsetDistance;

            accumulatedDistance = 0;
            leftSidePoints.push({ x: currentPoint.x + offsetX , y: currentPoint.y + offsetY });
            rightSidePoints.push({ x: currentPoint.x - offsetX , y: currentPoint.y - offsetY });
        }
    }
    
    return { leftSidePoints, rightSidePoints };
}

function createIsoscelesTriangleFromSpline(splinePoints, baseLengthMeters, heightMeters) {
    if (splinePoints.length < 2) {
        throw new Error("Potřeba alespoň dva body ve splinePoints");
    }

    const last = splinePoints[splinePoints.length - 1];
    const prev = splinePoints[splinePoints.length - 2];

    // Vektor směru (bearing)
    const dx = last.x - prev.x;
    const dy = last.y - prev.y;
    const bearing = (Math.atan2(dx, dy) * 180 / Math.PI + 360) % 360;

    const center = [last.x, last.y]; // GeoJSON formát: [lon, lat]

    const halfBase = baseLengthMeters / 2*100000;

    const leftBase = turf.destination(center, halfBase, bearing - 90, { units: 'meters' });
    const rightBase = turf.destination(center, halfBase, bearing + 90, { units: 'meters' });
    const apex = turf.destination(center, heightMeters*100000, bearing, { units: 'meters' });
    
    return [
        { x: leftBase.geometry.coordinates[0], y: leftBase.geometry.coordinates[1] },
        { x: apex.geometry.coordinates[0],      y: apex.geometry.coordinates[1] },
        { x: rightBase.geometry.coordinates[0], y: rightBase.geometry.coordinates[1] }
    ];
}


function computeArrowHead(splinePoints, width, length) {
    const len = splinePoints.length;
    const lastPoint = splinePoints[len - 1];
    const secondLastPoint = splinePoints[len - 2];
    //const x = (lastPoint.x - secondLastPoint.x);
    //const y = (lastPoint.y - secondLastPoint.y);
    const x = (lastPoint.x - secondLastPoint.x) ;
    const y = (lastPoint.y - secondLastPoint.y) ;
    const magnitude = Math.hypot(x, y);
    const normalizedX = x / magnitude;
    const normalizedY = y / magnitude;

    return [
        { x: lastPoint.x - normalizedY * width , y: lastPoint.y + normalizedX * width},
        { x: (lastPoint.x + normalizedX) * length, y: (lastPoint.y + normalizedY) * length},
        { x: lastPoint.x + normalizedY * width , y: lastPoint.y - normalizedX * width},
    ];
}

function exponentialWidthCurve(normalizedPosition, range = 5, minValue = 0.1) {
    return minValue + (1 - minValue) * Math.exp(-range * normalizedPosition); 
}

function linearWidthCurve(normalizedPosition, range = 1, minValue = 0.1) {
    return 1 + (minValue - 1) * normalizedPosition / range ;
}