package;

import haxe.Constraints.FlatEnum;
import haxe.ds.Map;

// import kha.Assets;
// import kha.Framebuffer;
// import kha.Scheduler;
// import kha.System;
// import kha.math.Random;

/**
 * Core: Will not change frequently
 */
interface IFuel {
    @:isVar public var requiredMaterials(get, null):Array<MaterialEnum>;
    @:isVar public var requiredFuels(get, null):Array<FuelEnum>;
    @:isVar public var fuel(get, null):FuelEnum;
    public function addRequiredMaterial(material:MaterialEnum, units:Float):Void;
    public function addRequiredFuel(fuel:FuelEnum, units:Float):Void;
}

/**
 * Core: Will not change frequently
 */
enum FuelEnum {
    Bio;
    Sun;
}

/**
 * Core: Will not change frequently
 */
class Fuel implements IFuel {
    @:isVar public var requiredMaterials(get, null):Array<MaterialEnum> = [];
    @:isVar public var requiredFuels(get, null):Array<FuelEnum> = [];
    @:isVar public var fuel(get, null):FuelEnum;
    @:isVar public var requiredMaterialUnits(get, null):Map<MaterialEnum, Float> = new Map();
    @:isVar public var requiredFuelUnits(get, null):Map<FuelEnum, Float> = new Map();

    public function new(fuel:FuelEnum) {
        this.fuel = fuel;
    }

    public function addRequiredMaterial(requiredMaterial:MaterialEnum, units:Float) {
        this.requiredMaterials.push(requiredMaterial);
        this.requiredMaterialUnits.set(requiredMaterial, units);
    }

    public function addRequiredMaterialUnits(requiredMaterial:MaterialEnum) {
        this.requiredMaterials.push(requiredMaterial);
    }

    public function addRequiredFuel(requiredfuel:FuelEnum, units:Float) {
        this.requiredFuels.push(requiredfuel);
        this.requiredFuelUnits.set(requiredfuel, units);
    }

    public function get_requiredMaterials():Array<MaterialEnum> {
        return requiredMaterials;
    }

    public function get_requiredFuels():Array<FuelEnum> {
        return requiredFuels;
    }

    public function get_fuel():FuelEnum {
        return fuel;
    }

    public function get_requiredMaterialUnits():Map<MaterialEnum, Float> {
        return requiredMaterialUnits;
    }

    public function get_requiredFuelUnits():Map<FuelEnum, Float> {
        return requiredFuelUnits;
    }
}

/**
 * Will change frequently/maybe will be replaced
 */
class FuelBio extends Fuel {
    public function new() {
        super(FuelEnum.Bio);
        this.addRequiredMaterial(MaterialEnum.M0, 2);
        this.addRequiredFuel(FuelEnum.Sun, 1);
    }

    public function calculateSomeShit():String {
        return "tadaaa";
    }
}

/**
 * Will change frequently/maybe will be replaced
 */
class FuelSun extends Fuel {
    public function new() {
        super(FuelEnum.Sun);
    }
}

/**
 * Core: Will not change frequently
 */
interface IMaterialProperty {}

/**
 * Core: Will not change frequently
 */
class MaterialProperty implements IMaterialProperty {
    public function new() {}
}

/**
 * Will change frequently/maybe will be replaced
 */
class MaterialPropertyTransport extends MaterialProperty {
    @:isVar public var transportsMaterials(get, null):Array<MaterialEnum> = [];
    @:isVar public var transportsFuels(get, null):Array<FuelEnum> = [];

    public function new(transportsMaterials:Array<MaterialEnum>, transportsFuels:Array<FuelEnum>) {
        this.transportsMaterials = transportsMaterials;
        this.transportsFuels = transportsFuels;
        super();
    }

    public function get_transportsMaterials():Array<MaterialEnum> {
        return transportsMaterials;
    }

    public function get_transportsFuels():Array<FuelEnum> {
        return transportsFuels;
    }
}

/**
 * Will change frequently/maybe will be replaced
 */
class MaterialPropertyFuel extends MaterialProperty {
    @:isVar public var fuel(get, null):Fuel;

    public function new(fuel:Fuel) {
        super();
        this.fuel = fuel;
    }

    public function get_fuel():Fuel {
        return fuel;
    }
}

/**
 * Will change frequently/maybe will be replaced
 */
enum MaterialEnum {
    M0;
    M1;
    M2;
}

/**
 * Core: Will not change frequently
 */
class Material {
    @:isVar public var properties(get, null):Array<MaterialProperty>;
    @:isVar public var material(get, null):MaterialEnum;

    public function new(material:MaterialEnum, properties:Array<MaterialProperty>) {
        this.properties = properties;
        this.material = material;
    }

    public function get_properties():Array<MaterialProperty> {
        return properties;
    }

    public function get_material():MaterialEnum {
        return material;
    }
}

/**
 * Core: Will not change frequently
 */
class MaterialGroup {
    @:isVar public var materials(get, null):Array<Material> = [];
    @:isVar public var minMaterialsRequired(get, null):Map<MaterialEnum, Float> = new Map();
    @:isVar public var minFuelRequired(get, null):Map<FuelEnum, Float> = new Map();

    public function new() {}

    public function addMaterial(material:Material) {
        this.materials.push(material);
    }

    public function get_materials():Array<Material> {
        return materials;
    }

    public function addMinMaterialsRequired(key:MaterialEnum, addUnit:Float) {
        var exUnit = minMaterialsRequired.get(key); // TODO i think there is an .contains fn
        if (exUnit != null) {
            var newUnit = exUnit + addUnit;
            minMaterialsRequired.set(key, newUnit);
        } else {
            minMaterialsRequired.set(key, addUnit);
        }
    }

    public function addMinFuelRequired(key:FuelEnum, addUnit:Float) {
        var exUnit = minFuelRequired.get(key); // TODO i think there is an .contains fn
        if (exUnit != null) {
            var newUnit = exUnit + addUnit;
            minFuelRequired.set(key, newUnit);
        } else {
            minFuelRequired.set(key, addUnit);
        }
    }

    public function get_minFuelRequired():Map<FuelEnum, Float> {
        return minFuelRequired;
    }

    public function get_minMaterialsRequired():Map<MaterialEnum, Float> {
        return minMaterialsRequired;
    }
}

/**
 * Will change frequently
 */
class MaterialPool {
    @:isVar public var materials(get, null):Map<MaterialEnum, Material> = new Map();
    @:isVar public var fuels(get, null):Map<FuelEnum, Fuel> = new Map();

    public function new() {
        fuels.set(FuelEnum.Bio, new FuelBio());
        fuels.set(FuelEnum.Sun, new Fuel(FuelEnum.Sun));

        var m0 = new Material(MaterialEnum.M0, []);
        var m1 = new Material(MaterialEnum.M1, [
            new MaterialPropertyTransport([MaterialEnum.M0], []),
            new MaterialPropertyFuel(fuels.get(FuelEnum.Bio))
        ]);
        var m2 = new Material(MaterialEnum.M2, [
            new MaterialPropertyTransport([], [FuelEnum.Sun]),
            new MaterialPropertyFuel(fuels.get(FuelEnum.Bio)) // TODO: this kind of sucks, because u have to not forget to register above
        ]);

        materials.set(MaterialEnum.M0, m0);
        materials.set(MaterialEnum.M1, m1);
        materials.set(MaterialEnum.M2, m2);
    }

    public function get_materials():Map<MaterialEnum, Material> {
        return materials;
    }

    public function get_fuels():Map<FuelEnum, Fuel> {
        return fuels;
    }

    private function genGroups(group:MaterialGroup, fuel:Fuel, transportMaterialMap:Map<MaterialEnum, Array<MaterialEnum>>,
            transportFuelMap:Map<FuelEnum, Array<MaterialEnum>>, rFuelUnits:Float = null, rMaterialUnits:Float = null):MaterialGroup {
        var fuelRequiredMaterials = fuel.requiredMaterials;
        var fuelRequiredfuels = fuel.requiredFuels;

        var idxRM = 0;

        for (fuelRequiredMaterial in fuelRequiredMaterials) {
            var materialUnits = fuel.requiredMaterialUnits.get(fuelRequiredMaterial);
            var transportMaterials = transportMaterialMap.get(fuelRequiredMaterial);

            // Find material that transports it and add
            if (transportMaterials != null && transportMaterials.length > 0 && materialUnits != null) {
                var tm = materials.get(transportMaterials[0]);

                if (tm != null) {
                    for (property in tm.properties) {
                        switch Type.typeof(property) {
                            // And transport material can has it's own depencies
                            case TClass(MaterialPropertyFuel):
                                var materialPropertyFuel = cast(property, MaterialPropertyFuel);
                                var fuelNext = materialPropertyFuel.fuel;

                                if (fuelNext.fuel != fuel.fuel) { // Avoid recursing same fuel
                                    group = genGroups(group, fuelNext, transportMaterialMap, transportFuelMap);
                                }
                            case _:
                        }
                    }

                    group.addMinMaterialsRequired(transportMaterials[0], materialUnits);
                    group.addMaterial(tm);
                }
            }

            idxRM++;
        }

        var idxRF = 0;

        // If Fuel depends on other materials or/and fuels, recurse
        for (fuelRequiredfuel in fuelRequiredfuels) {
            var fuelNext = fuels.get(fuelRequiredfuel);
            var fuelUnits = fuel.requiredFuelUnits.get(fuelRequiredfuel);

            if (fuelNext != null && fuelNext.fuel != fuel.fuel) {
                group = genGroups(group, fuelNext, transportMaterialMap, transportFuelMap, fuelUnits);
            }
            idxRF++;
        }

        // No requirements, raw fuel
        if (idxRM == 0 && idxRF == 0 && rFuelUnits != null) {
            // Find material that transports it and add
            var transportMaterials = transportFuelMap.get(fuel.fuel);

            if (transportMaterials != null && transportMaterials.length > 0) {
                var tm = materials.get(transportMaterials[0]);

                if (tm != null) {
                    group.addMinFuelRequired(fuel.fuel, rFuelUnits);
                    group.addMinMaterialsRequired(transportMaterials[0], rFuelUnits);
                    group.addMaterial(tm);
                }
            }
        }

        return group;
    }

    public function getGrops():Array<MaterialGroup> {
        var groups:Array<MaterialGroup> = [];

        var transportMaterialMap:Map<MaterialEnum, Array<MaterialEnum>> = new Map();
        var transportFuelMap:Map<FuelEnum, Array<MaterialEnum>> = new Map();

        for (material in materials) {
            for (property in material.properties) {
                switch Type.typeof(property) {
                    case TClass(MaterialPropertyTransport):
                        var materialPropertyFuel = cast(property, MaterialPropertyTransport);

                        for (transportsMaterial in materialPropertyFuel.transportsMaterials) {
                            var ex = transportMaterialMap.get(transportsMaterial);
                            if (ex != null) {
                                ex.push(material.material);
                                transportMaterialMap.set(transportsMaterial, ex);
                            } else {
                                transportMaterialMap.set(transportsMaterial, [material.material]);
                            }
                        }

                        for (transportsFuel in materialPropertyFuel.transportsFuels) {
                            var ex = transportFuelMap.get(transportsFuel);
                            if (ex != null) {
                                ex.push(material.material);
                                transportFuelMap.set(transportsFuel, ex);
                            } else {
                                transportFuelMap.set(transportsFuel, [material.material]);
                            }
                        }

                    case _:
                }
            }
        }

        for (material in materials) {
            var group = new MaterialGroup();
            var properties = material.properties;

            for (property in properties) {
                switch Type.typeof(property) {
                    case TClass(MaterialPropertyFuel):
                        var materialPropertyFuel = cast(property, MaterialPropertyFuel);
                        var fuel = materialPropertyFuel.fuel;

                        group = genGroups(group, fuel, transportMaterialMap, transportFuelMap);
                    case _:
                }
            }

            groups.push(group);
        }

        return groups;
    }
}

/**
 * Will change frequently
 */
class DNA {
    public function new() {}

    public function generateDNA(groups:Array<MaterialGroup>) {
        for (group in groups) {
            trace("/////////////////////////////////////");
            // trace("Group: " + group.materials.join(","));
            trace("Group cost (material): " + group.minMaterialsRequired);
            trace("Group cost (fuel): " + group.minFuelRequired);

            for (material in group.materials) {
                trace("-----------------------------");
                trace("Matrial: " + material.material);
                var properties = material.properties;

                for (property in properties) {
                    switch Type.typeof(property) {
                        case TClass(MaterialPropertyFuel):
                            trace("Fuel property");
                            var materialPropertyFuel = cast(property, MaterialPropertyFuel);

                            switch Type.typeof(materialPropertyFuel.fuel) {
                                case TClass(FuelBio):
                                    var fuelBio:FuelBio = cast(materialPropertyFuel.fuel, FuelBio);
                                    trace("Do bio fuel stuff: " + fuelBio.calculateSomeShit());
                                case _:
                                    trace("Other fuel stuff");
                            }
                        case _:
                            trace("Other property");
                    }
                }
            }
        }
    }
}

class Test {
    public function new() {
        var dna = new DNA();
        var mp = new MaterialPool();
        dna.generateDNA(mp.getGrops());
    }
}

class Main {
    /*static function update():Void {}
        static function render(frames:Array<Framebuffer>):Void {
    }*/
    public static function main() {
        var t = new Test();

        /*System.start({title: "Project", width: 1024, height: 768}, function(_) {
            // Just loading everything is ok for small projects
            Assets.loadEverything(function() {
                // Avoid passing update/render directly,
                // so replacing them via code injection works
                Scheduler.addTimeTask(function() {
                    update();
                }, 0, 1 / 60);
                System.notifyOnFrames(function(frames) {
                    render(frames);
                });
            });
        });*/
    }
}