import { TSize, TSurface, TTileCategoryValue, TTileValue } from "@/types/room";
import { defineStore } from "pinia";
import { computed, ref } from "vue";

export const useTileStore = defineStore("tile", () => {
    const selectedTile = ref<TTileValue | null>(null);
    const tileCategoriesValue = ref<TTileCategoryValue[]>([]);
    const selectedTileCategoryId = ref<number | null>(null);
    const allTile = ref<TTileValue[]>([]);
    const filteredTiles = ref<TTileValue[]>([]);
    const uniqueSize = ref<TSize[]>([]);
    const uniqueSurface = ref<TSurface[]>([]);
    const filterVariant = ref("All Variant");
    const filterSize = ref("All Size");
    const filterSurface = ref("All Surface");

    const tileByCategory = computed(() => {
        if (!selectedTileCategoryId.value || !allTile.value.length) return [];

        //Filter by Category
        filteredTiles.value = allTile.value.filter(
            (tile) => tile.category_id === selectedTileCategoryId.value
        );

        let variantTile = filteredTiles.value.flatMap((tile) => ({
            name: tile.name,
            variants: tile.variants.map((variant) => ({
                variant_name: variant.name,
                variant_attributes: variant.variant_attributes.map((attr) => ({
                    image: attr.image,
                    size: attr.size,
                    surface: attr.surface,
                })),
            })),
        }));

        const allSizes = variantTile.flatMap((tile) =>
            tile.variants.flatMap((variant) =>
                variant.variant_attributes.map((attr) => attr.size)
            )
        );

        uniqueSize.value = Array.from(
            new Map(allSizes.map((size) => [size.name, size])).values()
        );

        const allSurface = variantTile.flatMap((tile) =>
            tile.variants.flatMap((variant) =>
                variant.variant_attributes.map((attr) => attr.surface)
            )
        );

        uniqueSurface.value = Array.from(
            new Map(allSurface.map((surface)=> [surface.name, surface])).values()
        )

        //Filter by Variant
        if (
            filterVariant.value !== "" &&
            filterVariant.value !== "All Variant"
        ) {
            variantTile = variantTile.filter(
                (result) => result.name === filterVariant.value
            );
        }

        //Filter by Size
        if (filterSize.value !== "All Size" && filterSize.value !== "") {
            variantTile = variantTile
                .map((result) => ({
                    ...result,
                    variants: result.variants.map((variant) => ({
                        ...variant,
                        variant_attributes: variant.variant_attributes.filter(
                            (attr) => attr.size.name === filterSize.value
                        ),
                    })),
                }))

                .map((result) => ({
                    ...result,
                    variants: result.variants.filter(
                        (variant) => variant.variant_attributes.length > 0
                    ),
                }))

                .filter((result) => result.variants.length > 0);
        }

        //Filter by Surface
        if (
            filterSurface.value !== "All Surface" &&
            filterSurface.value !== ""
        ) {
            variantTile = variantTile
                .map((result) => ({
                    ...result,
                    variants: result.variants.map((variant) => ({
                        ...variant,
                        variant_attributes: variant.variant_attributes.filter(
                            (attr) => attr.surface.name === filterSurface.value
                        ),
                    })),
                }))

                .map((result) => ({
                    ...result,
                    variants: result.variants.filter(
                        (variant) => variant.variant_attributes.length > 0
                    ),
                }))

                .filter((result) => result.variants.length > 0);
        }

        if (variantTile.length === 0) {
            return [];
        }

        return variantTile;
    });

    const selectedTileCategory = computed(() => {
        if (!selectedTileCategoryId.value) return null;
        const category = tileCategoriesValue.value?.find(
            (cat) => cat.id === selectedTileCategoryId.value
        );

        return category;
    });

    const addTexture = computed(() => {
        return tileByCategory.value.flatMap((tile) =>
            tile.variants.flatMap((variant) =>
                variant.variant_attributes.map((attr) => ({
                    variant_name: variant.variant_name,
                    image: attr.image,
                    length: attr.size.length,
                    width: attr.size.width,
                    type: getType(attr.size.length, attr.size.width),
                }))
            )
        );
    });

    const getType = (length: number, width: number) => {
        if (length === width) {
            return "SQUARE";
        }
        if (String(length) === "122" && String(width) === "18") {
            return "PLANK";
        }
        return "RECTANGLE";
    };

    const setVariantFilter = (variant: string) => {
        filterVariant.value = variant;
    };

    const setSizeFilter = (size: string) => {
        filterSize.value = size;
    };

    const setSurfaceFilter = (surface: string) => {
        filterSurface.value = surface;
    };

    const setSelectedTileCategory = (id: number) => {
        selectedTileCategoryId.value = id;
    };

    const resetFilter = () => {
        filterSize.value = "All Size"
        filterSurface.value = "All Surface"
        filterVariant.value = "All Variant"
    }

    const resetSelectedTile = () => {
        selectedTileCategoryId.value = null;
    };

    return {
        selectedTile,
        tileCategoriesValue,
        selectedTileCategoryId,
        allTile,
        tileByCategory,
        selectedTileCategory,
        addTexture,
        filteredTiles,
        filterVariant,
        filterSize,
        filterSurface,
        uniqueSurface,
        uniqueSize,
        setSurfaceFilter,
        setSizeFilter,
        setVariantFilter,
        setSelectedTileCategory,
        resetSelectedTile,
        resetFilter
    };
});