nademitex_user/src/stores/catalog.ts

import { defineStore } from 'pinia'
import { ref } from 'vue'
import { apiRequest } from '@/services/http'
import type { BankAccount, Catalog, Company, Product } from '@/types'

export const useCatalogStore = defineStore('catalog', () => {
  const companies = ref<Company[]>([])
  const catalogs = ref<Catalog[]>([])
  const products = ref<Product[]>([])
  const bankAccounts = ref<BankAccount[]>([])
  const searchQuery = ref('')
  const loading = ref(false)
  const loaded = ref(false)

  async function loadCompanies(force = false) {
    if (loaded.value && !force) return companies.value
    loading.value = true
    try {
      const list = await apiRequest<Company[]>('/companies', {
        query: { activeOnly: true },
      })
      companies.value = list
        .filter((c) => c.isActive)
        .sort((a, b) => a.displayOrder - b.displayOrder)
      loaded.value = true
    } finally {
      loading.value = false
    }
    return companies.value
  }

  function getActiveCompanies(): Company[] {
    return [...companies.value].sort((a, b) => a.displayOrder - b.displayOrder)
  }

  function getCompany(id: string): Company | undefined {
    return companies.value.find((c) => c.id === id)
  }

  async function loadCatalogs(companyId: string) {
    const list = await apiRequest<Catalog[]>('/catalogs', {
      query: { companyId, activeOnly: true },
    })
    catalogs.value = [
      ...catalogs.value.filter((c) => c.companyId !== companyId),
      ...list,
    ]
    return list
  }

  async function loadProducts(catalogId: string, color?: string) {
    const list = await apiRequest<Product[]>('/products', {
      query: {
        catalogId,
        color: color && color !== 'all' ? color : undefined,
        activeOnly: true,
      },
    })
    const others = products.value.filter((p) => p.catalogId !== catalogId)
    products.value = [...others, ...list]
    return list
  }

  async function loadBankAccounts(companyId: string) {
    const list = await apiRequest<BankAccount[]>(`/companies/${companyId}/bank-accounts`)
    bankAccounts.value = [
      ...bankAccounts.value.filter((b) => b.companyId !== companyId),
      ...list.filter((b) => b.isActive),
    ]
    return bankAccounts.value.filter((b) => b.companyId === companyId)
  }

  function fetchCatalogs(companyId: string, query = ''): Catalog[] {
    let list = catalogs.value.filter((c) => c.companyId === companyId && c.isActive)
    if (query.trim()) {
      const q = query.trim()
      list = list.filter((c) => c.code.includes(q) || c.name.includes(q))
    }
    return [...list].sort((a, b) => a.displayOrder - b.displayOrder)
  }

  function fetchProducts(catalogId: string, colorFilter?: string): Product[] {
    let list = products.value.filter((p) => p.catalogId === catalogId && p.isActive)
    if (colorFilter && colorFilter !== 'all') {
      list = list.filter((p) => p.color.includes(colorFilter))
    }
    return list
  }

  function getCatalog(id: string) {
    return catalogs.value.find((c) => c.id === id)
  }

  function getProduct(id: string) {
    return products.value.find((p) => p.id === id)
  }

  function getUniqueColors(catalogId: string): string[] {
    return [...new Set(fetchProducts(catalogId).map((p) => p.color))]
  }

  function getBankAccountsByCompany(companyId: string): BankAccount[] {
    return bankAccounts.value
      .filter((b) => b.companyId === companyId && b.isActive)
      .sort((a, b) => a.displayOrder - b.displayOrder)
  }

  return {
    companies,
    catalogs,
    products,
    bankAccounts,
    searchQuery,
    loading,
    loaded,
    loadCompanies,
    loadCatalogs,
    loadProducts,
    loadBankAccounts,
    getActiveCompanies,
    getCompany,
    fetchCatalogs,
    fetchProducts,
    getCatalog,
    getProduct,
    getUniqueColors,
    getBankAccountsByCompany,
  }
})