mapcomplete/UI/BigComponents/FilterView.ts

import {Utils} from "../../Utils";
import {FixedInputElement} from "../Input/FixedInputElement";
import {RadioButton} from "../Input/RadioButton";
import {VariableUiElement} from "../Base/VariableUIElement";
import Toggle from "../Input/Toggle";
import Combine from "../Base/Combine";
import Translations from "../i18n/Translations";
import {Translation} from "../i18n/Translation";
import Svg from "../../Svg";
import {UIEventSource} from "../../Logic/UIEventSource";
import BaseUIElement from "../BaseUIElement";
import State from "../../State";
import FilteredLayer from "../../Models/FilteredLayer";
import BackgroundSelector from "./BackgroundSelector";
import FilterConfig from "../../Models/ThemeConfig/FilterConfig";

export default class FilterView extends VariableUiElement {
    constructor(filteredLayer: UIEventSource<FilteredLayer[]>) {
        const backgroundSelector = new Toggle(
            new BackgroundSelector(),
            undefined,
            State.state.featureSwitchBackgroundSlection
        )
        super(
            filteredLayer.map((filteredLayers) =>
                filteredLayers?.map(l => FilterView.createOneFilteredLayerElement(l)).concat(backgroundSelector)
            )
        );
    }

    private static createOneFilteredLayerElement(filteredLayer: FilteredLayer) {
        if (filteredLayer.layerDef.name === undefined) {
            // Name is not defined: we hide this one
            return undefined;
        }
        const iconStyle = "width:1.5rem;height:1.5rem;margin-left:1.25rem;flex-shrink: 0;";

        const icon = new Combine([Svg.checkbox_filled]).SetStyle(iconStyle);
        const iconUnselected = new Combine([Svg.checkbox_empty]).SetStyle(
            iconStyle
        );

        if (filteredLayer.layerDef.name === undefined) {
            return;
        }


        const name: Translation = Translations.WT(
            filteredLayer.layerDef.name
        )?.Clone();

        const styledNameChecked = name
            .Clone()
            .SetStyle("font-size:large;padding-left:1.25rem");

        const styledNameUnChecked = name
            .Clone()
            .SetStyle("font-size:large;padding-left:1.25rem");

        const zoomStatus =
            new Toggle(
                undefined,
                Translations.t.general.layerSelection.zoomInToSeeThisLayer.Clone()
                    .SetClass("alert")
                    .SetStyle("display: block ruby;width:min-content;"),
                State.state.locationControl.map(location => location.zoom >= filteredLayer.layerDef.minzoom)
            )


        const style =
            "display:flex;align-items:center;padding:0.5rem 0;";
        const layerChecked = new Combine([icon, styledNameChecked, zoomStatus])
            .SetStyle(style)
            .onClick(() => filteredLayer.isDisplayed.setData(false));

        const layerNotChecked = new Combine([iconUnselected, styledNameUnChecked])
            .SetStyle(style)
            .onClick(() => filteredLayer.isDisplayed.setData(true));


        const filterPanel: BaseUIElement = FilterView.createFilterPanel(filteredLayer)


        return new Toggle(
            new Combine([layerChecked, filterPanel]),
            layerNotChecked,
            filteredLayer.isDisplayed
        );
    }

    private static createFilterPanel(flayer: FilteredLayer): BaseUIElement {
        const layer = flayer.layerDef
        if (layer.filters.length === 0) {
            return undefined;
        }

        const filterIndexes = new Map<string, number>()
        layer.filters.forEach((f, i) => filterIndexes.set(f.id, i))

        let listFilterElements: [BaseUIElement, UIEventSource<{ filter: FilterConfig, selected: number }>][] = layer.filters.map(
            FilterView.createFilter
        );

        listFilterElements.forEach((inputElement, i) =>
            inputElement[1].addCallback((changed) => {
                const oldValue = flayer.appliedFilters.data
                
                if(changed === undefined){
                    // Lets figure out which filter should be removed
                    // We know this inputElement corresponds with layer.filters[i]
                    // SO, if there is a value in 'oldValue' with this filter, we have to recalculated
                    if(!oldValue.some(f => f.filter === layer.filters[i])){
                        // The filter to remove is already gone, we can stop
                        return;
                    }
                }else if(oldValue.some(f => f.filter === changed.filter && f.selected === changed.selected)){
                    // The changed value is already there
                    return;
                }
                const listTagsFilters = Utils.NoNull(
                    listFilterElements.map((input) => input[1].data)
                );

                flayer.appliedFilters.setData(listTagsFilters);
            })
        );

        flayer.appliedFilters.addCallbackAndRun(appliedFilters => {
            for (let i = 0; i < layer.filters.length; i++){
                const filter = layer.filters[i];
                let foundMatch = undefined
                for (const appliedFilter of appliedFilters) {
                    if(appliedFilter.filter === filter){
                        foundMatch = appliedFilter
                     break;   
                    }
                }
                
                listFilterElements[i][1].setData(foundMatch)
            }

        })

        return new Combine(listFilterElements.map(input => input[0].SetClass("mt-3")))
            .SetClass("flex flex-col ml-8 bg-gray-300 rounded-xl p-2")

    }

    private static createFilter(filterConfig: FilterConfig): [BaseUIElement, UIEventSource<{ filter: FilterConfig, selected: number }>] {
        if (filterConfig.options.length === 1) {
            let option = filterConfig.options[0];

            const icon = Svg.checkbox_filled_svg().SetClass("block mr-2");
            const iconUnselected = Svg.checkbox_empty_svg().SetClass("block mr-2");

            const toggle = new Toggle(
                new Combine([icon, option.question.Clone().SetClass("block")]).SetClass("flex"),
                new Combine([iconUnselected, option.question.Clone().SetClass("block")]).SetClass("flex")
            )
                .ToggleOnClick()
                .SetClass("block m-1")

            const selected = {
                filter: filterConfig,
                selected: 0
            }
            return [toggle, toggle.isEnabled.map(enabled => enabled ? selected : undefined, [],
                f => f?.filter === filterConfig && f?.selected === 0)
            ]
        }

        let options = filterConfig.options;

        const values = options.map((f, i) => ({
           filter: filterConfig, selected: i 
        }))
        const radio = new RadioButton(
            options.map(
                (option, i) =>
                    new FixedInputElement(option.question.Clone().SetClass("block"), i)
            ),
            {
                dontStyle: true
            }
        );
        return [radio, 
            radio.GetValue().map(
            i => values[i], 
                [],
            selected => {
                return selected?.selected
            }
        )]
    }
}