import {FlowStep} from "./FlowStep";
import Combine from "../Base/Combine";
import {Store} from "../../Logic/UIEventSource";
import LayerConfig from "../../Models/ThemeConfig/LayerConfig";
import {InputElement} from "../Input/InputElement";
import {AllKnownLayouts} from "../../Customizations/AllKnownLayouts";
import {FixedInputElement} from "../Input/FixedInputElement";
import Img from "../Base/Img";
import Title from "../Base/Title";
import {RadioButton} from "../Input/RadioButton";
import {And} from "../../Logic/Tags/And";
import {VariableUiElement} from "../Base/VariableUIElement";
import Toggleable from "../Base/Toggleable";
import {BBox} from "../../Logic/BBox";
import BaseUIElement from "../BaseUIElement";
import PresetConfig from "../../Models/ThemeConfig/PresetConfig";
import List from "../Base/List";
import Translations from "../i18n/Translations";

export default class SelectTheme extends Combine implements FlowStep<{
    features: any[],
    theme: string,
    layer: LayerConfig,
    bbox: BBox,
}> {

    public readonly Value: Store<{
        features: any[],
        theme: string,
        layer: LayerConfig,
        bbox: BBox,
    }>;
    public readonly IsValid: Store<boolean>;

    constructor(params: ({ features: any[], layer: LayerConfig, bbox: BBox, })) {
        const t = Translations.t.importHelper.selectTheme
        let options: InputElement<string>[] = AllKnownLayouts.layoutsList
            .filter(th => th.layers.some(l => l.id === params.layer.id))
            .filter(th => th.id !== "personal")
            .map(th => new FixedInputElement<string>(
                new Combine([
                    new Img(th.icon).SetClass("block h-12 w-12 br-4"),
                    new Title(th.title)
                ]).SetClass("flex items-center"),
                th.id))


        const themeRadios = new RadioButton<string>(options, {
            selectFirstAsDefault: false
        })


        const applicablePresets = themeRadios.GetValue().map(theme => {
            if (theme === undefined) {
                return []
            }
            // we get the layer with the correct ID via the actual theme config, as the actual theme might have different presets due to overrides
            const themeConfig = AllKnownLayouts.layoutsList.find(th => th.id === theme)
            const layer = themeConfig.layers.find(l => l.id === params.layer.id)
            return layer.presets
        })


        const nonMatchedElements = applicablePresets.map(presets => {
            if (presets === undefined || presets.length === 0) {
                return undefined
            }
            return params.features.filter(feat => !presets.some(preset => new And(preset.tags).matchesProperties(feat.properties)))
        })

        super([
            new Title(t.title),
           t.intro,
            themeRadios,
            new VariableUiElement(applicablePresets.map(applicablePresets => {
                if (themeRadios.GetValue().data === undefined) {
                    return undefined
                }
                if (applicablePresets === undefined || applicablePresets.length === 0) {
                    return t.noMatchingPresets.SetClass("alert")
                }
            }, [themeRadios.GetValue()])),

            new VariableUiElement(nonMatchedElements.map(unmatched => SelectTheme.nonMatchedElementsPanel(unmatched, applicablePresets.data), [applicablePresets]))
        ]);
        this.SetClass("flex flex-col")

        this.Value = themeRadios.GetValue().map(theme => ({
            features: params.features,
            layer: params.layer,
            bbox: params.bbox,
            theme
        }))

        this.IsValid = this.Value.map(obj => {
            if (obj === undefined) {
                return false;
            }
            if ([obj.theme, obj.features].some(v => v === undefined)) {
                return false;
            }
            if (applicablePresets.data === undefined || applicablePresets.data.length === 0) {
                return false
            }
            if ((nonMatchedElements.data?.length ?? 0) > 0) {
                return false;
            }

            return true;

        }, [applicablePresets])
    }

    private static nonMatchedElementsPanel(unmatched: any[], applicablePresets: PresetConfig[]): BaseUIElement {
        if (unmatched === undefined || unmatched.length === 0) {
            return
        }
  const t = Translations.t.importHelper.selectTheme
      
        const applicablePresetsOverview = applicablePresets.map(preset => 
            t.needsTags.Subs(
                {title: preset.title, 
                    tags:preset.tags.map(t => t.asHumanString()).join(" & ") })
                .SetClass("thanks")
        );

        const unmatchedPanels: BaseUIElement[] = []
        for (const feat of unmatched) {
            const parts: BaseUIElement[] = []
            parts.push(new Combine(Object.keys(feat.properties).map(k => 
                k+"="+feat.properties[k]
            )).SetClass("flex flex-col"))

            for (const preset of applicablePresets) {
                const tags = new And(preset.tags).asChange({})
                const missing = []
                for (const {k, v} of tags) {
                    if (preset[k] === undefined) {
                        missing.push(t.missing.Subs({k,v}))
                    } else if (feat.properties[k] !== v) {
                        missing.push(t.misMatch.Subs({k, v, properties: feat.properties}))
                    }
                }

                if (missing.length > 0) {
                    parts.push(
                        new Combine([
                            t.notApplicable.Subs(preset),
                            new List(missing)
                        ]).SetClass("flex flex-col alert")
                    )
                }

            }

            unmatchedPanels.push(new Combine(parts).SetClass("flex flex-col"))
        }

        return new Combine([
            t.displayNonMatchingCount.Subs(unmatched).SetClass("alert"),
            ...applicablePresetsOverview,
            new Toggleable(new Title(t.unmatchedTitle),
                new Combine(unmatchedPanels))
        ]).SetClass("flex flex-col")

    }


}