package data.shipsystems.scripts;

import com.fs.starfarer.api.combat.MutableShipStatsAPI;
import com.fs.starfarer.api.plugins.ShipSystemStatsScript;
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.combat.CombatEngineAPI;
import com.fs.starfarer.api.combat.EveryFrameCombatPlugin;
import com.fs.starfarer.api.combat.ShipAPI;
import com.fs.starfarer.api.input.InputEventAPI;

import org.lazywizard.lazylib.MathUtils;
import org.lazywizard.lazylib.combat.CombatUtils;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class flux_parasites implements ShipSystemStatsScript, EveryFrameCombatPlugin {

    private CombatEngineAPI engine;

    public static final String SYSTEM_ID = "INSERT_SHIT_HERE";

    public static final float RANGE = 2000f;
    public static final float ACCURACY_BONUS = 50f;
    public static final float RANGE_BONUS = 20f;

    private static final Set<ShipAPI> masters = new LinkedHashSet<>();
    private static final Map<ShipAPI, ShipAPI> slaves = new LinkedHashMap<>();

    @Override
    public void apply(MutableShipStatsAPI stats, String id, State state, float effectLevel) {
        ShipAPI ship = (ShipAPI) stats.getEntity();

        if (!masters.contains(ship)) {
            masters.add(ship);
        }
    }

    @Override
    public void unapply(MutableShipStatsAPI stats, String id) {
        ShipAPI ship = (ShipAPI) stats.getEntity();

        if (masters.contains(ship)) {
            masters.remove(ship);
        }
    }

    @Override
    public StatusData getStatusData(int index, State state, float effectLevel) {
        if (index == 0) {
            return new StatusData("released", false);
        }
        return null;
    }

    @Override
    public void advance(float amount, List<InputEventAPI> events) {
        if (engine != Global.getCombatEngine()) {
            masters.clear();
            slaves.clear();
            this.engine = Global.getCombatEngine();
            return;
        }

        // Forcefully clean up dead masters, just in case
        Iterator<ShipAPI> iter1 = masters.iterator();
        while (iter1.hasNext()) {
            ShipAPI ship = iter1.next();

            if (ship.isHulk() || !engine.isEntityInPlay(ship)) {
                iter1.remove();
            }
        }

        // Unbuff ships outside of range of any master
        Iterator<Map.Entry<ShipAPI, ShipAPI>> iter2 = slaves.entrySet().iterator();
        while (iter2.hasNext()) {
            Map.Entry<ShipAPI, ShipAPI> entry = iter2.next();

            ShipAPI ship = entry.getKey();
            ShipAPI master = entry.getValue();

            if (MathUtils.getDistance(ship, master) > RANGE) {
                boolean foundMaster = false;

                List<ShipAPI> newMasters = CombatUtils.getShipsWithinRange(ship.getLocation(), RANGE);
                for (ShipAPI newMaster : newMasters) {
                    if (ship == newMaster || newMaster.getOwner() != ship.getOwner()) {
                        continue;
                    }

                    if (masters.contains(newMaster)) {
                        entry.setValue(newMaster);
                        foundMaster = true;
                        break;
                    }
                }

                // No master: no more buffs
                if (!foundMaster) {
                    ship.getMutableStats().getAutofireAimAccuracy().unmodify(SYSTEM_ID);
                    ship.getMutableStats().getFluxCapacity().unmodify(SYSTEM_ID);
                    ship.getMutableStats().getFluxDissipation().unmodify(SYSTEM_ID);

                    iter2.remove();
                }
            }
        }

        // Buff ships within range
        for (ShipAPI master : masters) {
            if (master.isHulk()) {
                continue;
            }

            List<ShipAPI> ships = CombatUtils.getShipsWithinRange(master.getLocation(), RANGE);
            for (ShipAPI ship : ships) {
                if (ship == master || master.getOwner() != ship.getOwner()) {
                    continue;
                }

                if (!slaves.containsKey(ship)) {
                    ship.getMutableStats().getAutofireAimAccuracy().modifyPercent(SYSTEM_ID, ACCURACY_BONUS);
                    ship.getMutableStats().getFluxCapacity().modifyPercent(SYSTEM_ID, RANGE_BONUS);
                    ship.getMutableStats().getFluxDissipation().modifyPercent(SYSTEM_ID, RANGE_BONUS);

                    slaves.put(ship, master);
                }
            }
        }
    }

    @Override
    public void init(CombatEngineAPI engine) {
    }
}