import { Store, UIEventSource } from "../../Logic/UIEventSource"
import Combine from "../Base/Combine"
import BaseUIElement from "../BaseUIElement"
import { SubtleButton } from "../Base/SubtleButton"
import Svg from "../../Svg"
import Translations from "../i18n/Translations"
import { VariableUiElement } from "../Base/VariableUIElement"
import Toggle from "../Input/Toggle"
import { UIElement } from "../UIElement"
import { FixedUiElement } from "../Base/FixedUiElement"

export interface FlowStep<T> extends BaseUIElement {
    readonly IsValid: Store<boolean>
    readonly Value: Store<T>
}

export class FlowPanelFactory<T> {
    private _initial: FlowStep<any>
    private _steps: ((x: any) => FlowStep<any>)[]
    private _stepNames: (string | BaseUIElement)[]

    private constructor(
        initial: FlowStep<any>,
        steps: ((x: any) => FlowStep<any>)[],
        stepNames: (string | BaseUIElement)[]
    ) {
        this._initial = initial
        this._steps = steps
        this._stepNames = stepNames
    }

    public static start<TOut>(
        name: { title: BaseUIElement },
        step: FlowStep<TOut>
    ): FlowPanelFactory<TOut> {
        return new FlowPanelFactory(step, [], [name.title])
    }

    public then<TOut>(
        name: string | { title: BaseUIElement },
        construct: (t: T) => FlowStep<TOut>
    ): FlowPanelFactory<TOut> {
        return new FlowPanelFactory<TOut>(
            this._initial,
            this._steps.concat([construct]),
            this._stepNames.concat([name["title"] ?? name])
        )
    }

    public finish(
        name: string | BaseUIElement,
        construct: (t: T, backButton?: BaseUIElement) => BaseUIElement
    ): {
        flow: BaseUIElement
        furthestStep: UIEventSource<number>
        titles: (string | BaseUIElement)[]
    } {
        const furthestStep = new UIEventSource(0)
        // Construct all the flowpanels step by step (in reverse order)
        const nextConstr: ((t: any, back?: UIElement) => BaseUIElement)[] = this._steps.map(
            (_) => undefined
        )
        nextConstr.push(construct)
        for (let i = this._steps.length - 1; i >= 0; i--) {
            const createFlowStep: (value) => FlowStep<any> = this._steps[i]
            const isConfirm = i == this._steps.length - 1
            nextConstr[i] = (value, backButton) => {
                const flowStep = createFlowStep(value)
                furthestStep.setData(i + 1)
                const panel = new FlowPanel(flowStep, nextConstr[i + 1], backButton, isConfirm)
                panel.isActive.addCallbackAndRun((active) => {
                    if (active) {
                        furthestStep.setData(i + 1)
                    }
                })
                return panel
            }
        }

        const flow = new FlowPanel(this._initial, nextConstr[0])
        flow.isActive.addCallbackAndRun((active) => {
            if (active) {
                furthestStep.setData(0)
            }
        })
        return {
            flow,
            furthestStep,
            titles: this._stepNames,
        }
    }
}

export class FlowPanel<T> extends Toggle {
    public isActive: UIEventSource<boolean>

    constructor(
        initial: FlowStep<T>,
        constructNextstep: (input: T, backButton: BaseUIElement) => BaseUIElement,
        backbutton?: BaseUIElement,
        isConfirm = false
    ) {
        const t = Translations.t.general

        const currentStepActive = new UIEventSource(true)

        let nextStep: UIEventSource<BaseUIElement> = new UIEventSource<BaseUIElement>(undefined)
        const backButtonForNextStep = new SubtleButton(Svg.back_svg(), t.back).onClick(() => {
            currentStepActive.setData(true)
        })

        let elements: (BaseUIElement | string)[] = []
        const isError = new UIEventSource(false)
        if (initial !== undefined) {
            // Startup the flow
            elements = [
                initial,

                new Combine([
                    backbutton,
                    new Toggle(
                        new SubtleButton(
                            isConfirm
                                ? Svg.checkmark_svg()
                                : Svg.back_svg().SetStyle("transform: rotate(180deg);"),
                            isConfirm ? t.confirm : t.next
                        ).onClick(() => {
                            try {
                                const v = initial.Value.data
                                nextStep.setData(constructNextstep(v, backButtonForNextStep))
                                currentStepActive.setData(false)
                            } catch (e) {
                                console.error(e)
                                isError.setData(true)
                            }
                        }),
                        new SubtleButton(Svg.invalid_svg(), t.notValid),
                        initial.IsValid
                    ),
                    new Toggle(t.error.SetClass("alert"), undefined, isError),
                ]).SetClass("flex w-full justify-end space-x-2"),
            ]
        }

        super(
            new Combine(elements).SetClass("h-full flex flex-col justify-between"),
            new VariableUiElement(nextStep),
            currentStepActive
        )
        this.isActive = currentStepActive
    }
}