let MIN_ENERGY_PERCENT = 20;
let TARGET_ENERGY_PERCENT = 15;

function CreateSlider(container, label, defaultValue, onchange) {
    let SliderLabel = document.createElement('label');
    SliderLabel.innerText = label;
    SliderLabel.style.display = 'block';

    let Slider = document.createElement('input');
    Slider.type = 'range';
    Slider.min = '0';
    Slider.max = '100';
    Slider.step = '1';
    Slider.value = defaultValue;
    Slider.style.width = '80%';
    Slider.style.height = '24px';

    let PercentLabel = document.createElement('span');
    PercentLabel.innerText = `${Slider.value}%`;
    PercentLabel.style.float = 'right';

    Slider.onchange = (evt) => {
        PercentLabel.innerText = `${evt.target.value}%`;
        onchange(evt.target.value);
    }

    container.appendChild(SliderLabel);
    container.appendChild(Slider);
    container.appendChild(PercentLabel);
}

function CreateButton(container, label, onclick) {
    let Button = document.createElement('button');
    Button.style.width = '100%';
    Button.style.marginBottom = '10px';
    Button.innerHTML = label;
    Button.onclick = onclick;
    container.appendChild(Button);
    return Button;
}

class Plugin {
    constructor() {
        this.preview = null;
        this.previewColor = 'yellow';
    }

    draw(ctx) {
        if (this.preview) {
            drawLineBetweenPlanets(ctx, this.preview[0], this.preview[1], this.previewColor);
        }
    }

    render(container) {
        container.style.width = '400px';

        CreateSlider(container, 'Minimum energy % to leave', MIN_ENERGY_PERCENT, (value) => {MIN_ENERGY_PERCENT = value});
        CreateSlider(container, 'Target energy % to fill', TARGET_ENERGY_PERCENT, (value) => {TARGET_ENERGY_PERCENT = value});

        let InfoLabel = document.createElement('label');
        let UpdateInfo = (info) => {
            console.log(info);
            if (!info) {
                this.preview = null;
                InfoLabel.innerText = 'No candidate planets found';
            } else {
                this.preview = info[0];
                InfoLabel.innerText = `Sending ${info[1]} energy and ${info[2]} silver (${(info[1]-info[3])} energy spent in transit, ${info[3]} reaching destination)`;
            }
        };

        let PreviewEnergyButton = CreateButton(container, 'Preview energy move', () => {
            UpdateInfo(sendPayload(true, false));
            this.previewColor = 'blue';
        });
        PreviewEnergyButton.style.width = 'calc(50% - 5px)';

        let PreviewSilverButton = CreateButton(container, 'Preview silver move', () => {
            UpdateInfo(sendPayload(true, true));
            this.previewColor = 'yellow';
        });
        PreviewSilverButton.style.width = 'calc(50% - 5px)';
        PreviewSilverButton.style.marginLeft = '10px';

        let SendEnergyButton = CreateButton(container, 'Send energy to selected', () => {
            UpdateInfo(sendPayload(false, false));
            this.preview = null;
        });

        let SendSilverButton = CreateButton(container, 'Send silver to selected', () => {
            UpdateInfo(sendPayload(false, true));
            this.preview = null;
        });

        let ClearButton = CreateButton(container, 'Clear preview', () => {
            this.preview = null;
        });

        InfoLabel.style.width = '100%';
        container.appendChild(InfoLabel);
    }
}

export default Plugin;

function getEnergyBudget(planet) {
    return Math.max(0, Math.floor(planet.energy - planet.energyCap*MIN_ENERGY_PERCENT/100));
}

function getEnergyToSend(source, target) {
    let desiredEnergy = target.energyCap*TARGET_ENERGY_PERCENT/100;
    let futureEnergy = df.getAllVoyages()
        .filter(arrival => arrival.toPlanet === target.locationId)
        .reduce((seed, arrival) => seed + arrival.energyArriving, target.owner === df.account ? target.energy : -target.energy);
    let energyToDeliver = Math.max(1, Math.ceil(desiredEnergy - futureEnergy));
    let requiredEnergy = Math.ceil(df.getEnergyNeededForMove(source.locationId, target.locationId, energyToDeliver));
    let sendingEnergy = Math.min(getEnergyBudget(source), requiredEnergy);
    let arrivingEnergy = Math.floor(df.getEnergyArrivingForMove(source.locationId, target.locationId, distance(source, target), sendingEnergy));
    return [sendingEnergy, arrivingEnergy];
}

function getSilverToSend(source, target) {
    let futureSilver = df.getAllVoyages()
        .filter(arrival => arrival.toPlanet === target.locationId)
        .reduce((seed, arrival) => seed + arrival.silverMoved, target.silver);
    return Math.min(Math.floor(source.silver), Math.ceil(target.silverCap - futureSilver));
}

function sendPayload(previewing = false, sendSilver = false) {
    let selectedPlanet = ui.getSelectedPlanet();
    if (selectedPlanet) {
        let targetData = df.getMyPlanets()
            .filter(p => p.locationId !== selectedPlanet.locationId)
            .map(source => {
                let moveCost = Math.ceil(df.getEnergyNeededForMove(source.locationId, selectedPlanet.locationId, 1));
                return [source, moveCost];
            })
            .filter(p => getEnergyBudget(p[0]) > p[1] && (!sendSilver || p[0].silver > 0))
            .map(p => p[0])
            .map(source => {
                let [cost, arriving] = getEnergyToSend(source, selectedPlanet);
                let silver = sendSilver ? getSilverToSend(source, selectedPlanet) : 0;
                let costPerUnit = sendSilver ? cost/silver : cost/arriving;
                return [source, costPerUnit, cost, silver, arriving];
            })
        console.log(targetData);
        if (targetData.length > 0) {
            let [source, costPerUnit, energy, silver, arriving] = targetData.reduce((seed, current) => (seed && seed[1] < current[1] ? seed : current));
            if (!previewing) {
                df.move(source.locationId, selectedPlanet.locationId, energy, silver);
            }
            return [[source, selectedPlanet], energy, silver, arriving];
        }
    }
}

function distance(from, to) {
    let a = from.location, b = to.location;
    return Math.sqrt((a.coords.x - b.coords.x)**2 + (a.coords.y - b.coords.y)**2);
}

function drawLineBetweenPlanets(ctx, planetA, planetB, color, thickness=3) {
    const viewport = ui.getViewport();
    const startPoint = viewport.worldToCanvasCoords(planetA.location.coords);
    const endPoint = viewport.worldToCanvasCoords(planetB.location.coords);
    drawLine(ctx, startPoint, endPoint, color, thickness);
}
function drawLine(ctx, startPoint, endPoint, color, thickness=3) {
    ctx.beginPath();
    ctx.moveTo(startPoint.x, startPoint.y);
    ctx.lineTo(endPoint.x, endPoint.y);
    ctx.strokeStyle = color;
    ctx.lineWidth = thickness;
    ctx.stroke();
}