import Testing
@testable import PediFoods

@Test("Store catalog normalizer makes IDs non-empty and unique")
func storeCatalogNormalizerMakesIdsUnique() {
    let catalog = [
        StoreCatalogCategory(
            id: "",
            name: "Pizzas",
            isPizzaCategory: true,
            pizzaConfig: StorePizzaConfig(
                sizes: [
                    StorePizzaSize(id: "", name: "Grande", slices: 8, maxFlavors: 2),
                    StorePizzaSize(id: "", name: "Familia", slices: 12, maxFlavors: 3)
                ],
                doughs: [
                    StorePizzaDough(id: "massa", name: "Tradicional", active: true),
                    StorePizzaDough(id: "massa", name: "Fina", active: true)
                ],
                crusts: [
                    StorePizzaCrust(id: "", name: "Cheddar", active: true, priceModifier: 5),
                    StorePizzaCrust(id: "", name: "Catupiry", active: true, priceModifier: 6)
                ]
            ),
            products: [
                StoreCatalogProduct(
                    id: "",
                    type: "pizza",
                    name: "Calabresa",
                    description: nil,
                    image: nil,
                    price: 10,
                    originalPrice: nil,
                    pizzaPrices: [:],
                    addonGroups: [
                        StoreAddonGroup(
                            id: "",
                            name: "Extras",
                            minSelectors: nil,
                            maxSelectors: nil,
                            items: [
                                StoreAddonItem(id: "", name: "Bacon", price: 2),
                                StoreAddonItem(id: "", name: "Bacon em dobro", price: 4)
                            ]
                        ),
                        StoreAddonGroup(
                            id: "",
                            name: "Molhos",
                            minSelectors: nil,
                            maxSelectors: nil,
                            items: [
                                StoreAddonItem(id: "", name: "Alho", price: 1)
                            ]
                        )
                    ]
                ),
                StoreCatalogProduct(
                    id: "",
                    type: "pizza",
                    name: "Mussarela",
                    description: nil,
                    image: nil,
                    price: 12,
                    originalPrice: nil,
                    pizzaPrices: [:],
                    addonGroups: []
                )
            ]
        ),
        StoreCatalogCategory(
            id: "",
            name: "Bebidas",
            isPizzaCategory: false,
            pizzaConfig: nil,
            products: [
                StoreCatalogProduct(
                    id: "",
                    type: nil,
                    name: "Refrigerante",
                    description: nil,
                    image: nil,
                    price: 7,
                    originalPrice: nil,
                    pizzaPrices: [:],
                    addonGroups: []
                )
            ]
        )
    ]

    let normalized = StoreCatalogNormalizer.sanitize(categories: catalog, storeId: "store-1")

    let categoryIds = normalized.map(\.id)
    #expect(Set(categoryIds).count == categoryIds.count)
    #expect(categoryIds.allSatisfy { $0.isEmpty == false })

    let firstCategory = normalized[0]
    let productIds = firstCategory.products.map(\.id)
    #expect(Set(productIds).count == productIds.count)
    #expect(productIds.allSatisfy { $0.isEmpty == false })

    let addonGroupIds = firstCategory.products[0].addonGroups.map(\.id)
    #expect(Set(addonGroupIds).count == addonGroupIds.count)
    #expect(addonGroupIds.allSatisfy { $0.isEmpty == false })

    let addonItemIds = firstCategory.products[0].addonGroups.flatMap(\.items).map(\.id)
    #expect(Set(addonItemIds).count == addonItemIds.count)
    #expect(addonItemIds.allSatisfy { $0.isEmpty == false })

    let sizeIds = firstCategory.pizzaConfig?.sizes.map(\.id) ?? []
    let doughIds = firstCategory.pizzaConfig?.doughs.map(\.id) ?? []
    let crustIds = firstCategory.pizzaConfig?.crusts.map(\.id) ?? []

    #expect(Set(sizeIds).count == sizeIds.count)
    #expect(Set(doughIds).count == doughIds.count)
    #expect(Set(crustIds).count == crustIds.count)
}