import {
  users,
  groups,
  suppliers,
  orders,
  deliveries,
  userGroups,
  publicities,
  publicityParticipations,
  customerOrders,
  dlcProducts,
  tasks,
  nocodbConfig,
  invoiceVerificationCache,
  type User,
  type UpsertUser,
  type Group,
  type InsertGroup,
  type Supplier,
  type InsertSupplier,
  type Order,
  type InsertOrder,
  type Delivery,
  type InsertDelivery,
  type UserGroup,
  type InsertUserGroup,
  type OrderWithRelations,
  type DeliveryWithRelations,
  type UserWithGroups,
  type Publicity,
  type InsertPublicity,
  type PublicityParticipation,
  type InsertPublicityParticipation,
  type PublicityWithRelations,
  type CustomerOrder,
  type InsertCustomerOrder,
  type CustomerOrderWithRelations,
  type DlcProduct,
  type InsertDlcProduct,
  type DlcProductFrontend,
  type InsertDlcProductFrontend,
  type DlcProductWithRelations,
  type Task,
  type InsertTask,
  type NocodbConfig,
  type InsertNocodbConfig,
  type InvoiceVerificationCache,
  type InsertInvoiceVerificationCache,
} from "@shared/schema";
import { db } from "./db";
import { eq, and, inArray, desc, sql, gte, lte, lt, or, isNull, isNotNull } from "drizzle-orm";

export interface IStorage {
  // User operations
  getUser(id: string): Promise<User | undefined>;
  getUserByEmail(email: string): Promise<User | undefined>;
  getUserByUsername(username: string): Promise<User | undefined>;
  upsertUser(user: UpsertUser): Promise<User>;
  getUserWithGroups(id: string): Promise<UserWithGroups | undefined>;
  getUsers(): Promise<User[]>;
  createUser(user: UpsertUser): Promise<User>;
  updateUser(id: string, user: Partial<UpsertUser>): Promise<User>;
  deleteUser(id: string): Promise<void>;
  
  // Group operations
  getGroups(): Promise<Group[]>;
  getGroup(id: number): Promise<Group | undefined>;
  createGroup(group: InsertGroup): Promise<Group>;
  updateGroup(id: number, group: Partial<InsertGroup>): Promise<Group>;
  deleteGroup(id: number): Promise<void>;
  
  // Supplier operations
  getSuppliers(): Promise<Supplier[]>;
  createSupplier(supplier: InsertSupplier): Promise<Supplier>;
  updateSupplier(id: number, supplier: Partial<InsertSupplier>): Promise<Supplier>;
  deleteSupplier(id: number): Promise<void>;
  
  // Order operations
  getOrders(groupIds?: number[]): Promise<OrderWithRelations[]>;
  getOrdersByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise<OrderWithRelations[]>;
  getOrder(id: number): Promise<OrderWithRelations | undefined>;
  createOrder(order: InsertOrder): Promise<Order>;
  updateOrder(id: number, order: Partial<InsertOrder>): Promise<Order>;
  deleteOrder(id: number): Promise<void>;
  
  // Delivery operations
  getDeliveries(groupIds?: number[]): Promise<DeliveryWithRelations[]>;
  getDeliveriesByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise<DeliveryWithRelations[]>;
  getDelivery(id: number): Promise<DeliveryWithRelations | undefined>;
  createDelivery(delivery: InsertDelivery): Promise<Delivery>;
  updateDelivery(id: number, delivery: Partial<InsertDelivery>): Promise<Delivery>;
  deleteDelivery(id: number): Promise<void>;
  validateDelivery(id: number, blData?: { blNumber: string; blAmount: number }): Promise<void>;
  
  // User-Group operations
  getUserGroups(userId: string): Promise<UserGroup[]>;
  assignUserToGroup(userGroup: InsertUserGroup): Promise<UserGroup>;
  removeUserFromGroup(userId: string, groupId: number): Promise<void>;
  
  // Statistics
  getMonthlyStats(year: number, month: number, groupIds?: number[]): Promise<{
    ordersCount: number;
    deliveriesCount: number;
    pendingOrdersCount: number;
    averageDeliveryTime: number;
    totalPalettes: number;
    totalPackages: number;
  }>;

  // Publicity operations
  getPublicities(year?: number, groupIds?: number[]): Promise<PublicityWithRelations[]>;
  getPublicity(id: number): Promise<PublicityWithRelations | undefined>;
  createPublicity(publicity: InsertPublicity): Promise<Publicity>;
  updatePublicity(id: number, publicity: Partial<InsertPublicity>): Promise<Publicity>;
  deletePublicity(id: number): Promise<void>;
  
  // Publicity participation operations
  getPublicityParticipations(publicityId: number): Promise<PublicityParticipation[]>;
  setPublicityParticipations(publicityId: number, groupIds: number[]): Promise<void>;
  
  // NocoDB Configuration operations
  getNocodbConfigs(): Promise<NocodbConfig[]>;
  getNocodbConfig(id: number): Promise<NocodbConfig | undefined>;
  getActiveNocodbConfig(): Promise<NocodbConfig | undefined>;
  createNocodbConfig(config: InsertNocodbConfig): Promise<NocodbConfig>;
  updateNocodbConfig(id: number, config: Partial<InsertNocodbConfig>): Promise<NocodbConfig>;
  deleteNocodbConfig(id: number): Promise<void>;
  
  // Invoice Verification Cache operations
  getInvoiceVerificationCache(cacheKey: string): Promise<InvoiceVerificationCache | undefined>;
  createInvoiceVerificationCache(cache: InsertInvoiceVerificationCache): Promise<InvoiceVerificationCache>;
  clearExpiredCache(): Promise<void>;
  
  // Customer Order operations
  getCustomerOrders(groupIds?: number[]): Promise<CustomerOrderWithRelations[]>;
  getCustomerOrder(id: number): Promise<CustomerOrderWithRelations | undefined>;
  createCustomerOrder(customerOrder: InsertCustomerOrder): Promise<CustomerOrder>;
  updateCustomerOrder(id: number, customerOrder: Partial<InsertCustomerOrder>): Promise<CustomerOrder>;
  deleteCustomerOrder(id: number): Promise<void>;

  // DLC Product operations
  getDlcProducts(groupIds?: number[], filters?: { status?: string; supplierId?: number; }): Promise<DlcProductWithRelations[]>;
  getDlcProduct(id: number): Promise<DlcProductWithRelations | undefined>;
  createDlcProduct(dlcProduct: InsertDlcProductFrontend): Promise<DlcProductFrontend>;
  updateDlcProduct(id: number, dlcProduct: Partial<InsertDlcProductFrontend>): Promise<DlcProductFrontend>;
  deleteDlcProduct(id: number): Promise<void>;
  validateDlcProduct(id: number, validatedBy: string): Promise<DlcProductFrontend>;
  getDlcStats(groupIds?: number[]): Promise<{ active: number; expiringSoon: number; expired: number; }>;

  // Task operations
  getTasks(groupIds?: number[]): Promise<any[]>;
  getTask(id: number): Promise<any | undefined>;
  createTask(task: InsertTask): Promise<Task>;
  updateTask(id: number, task: Partial<InsertTask>): Promise<Task>;
  deleteTask(id: number): Promise<void>;
  completeTask(id: number, completedBy?: string): Promise<void>;
}

export class DatabaseStorage implements IStorage {
  // User operations
  async getUser(id: string): Promise<User | undefined> {
    const [user] = await db.select().from(users).where(eq(users.id, id));
    return user;
  }

  async getUserByEmail(email: string): Promise<User | undefined> {
    const [user] = await db.select().from(users).where(eq(users.email, email));
    return user;
  }

  async getUserByUsername(username: string): Promise<User | undefined> {
    const [user] = await db.select().from(users).where(eq(users.username, username));
    return user;
  }

  async upsertUser(userData: UpsertUser): Promise<User> {
    const [user] = await db
      .insert(users)
      .values(userData)
      .onConflictDoUpdate({
        target: users.id,
        set: {
          ...userData,
          updatedAt: new Date(),
        },
      })
      .returning();
    return user;
  }

  async getUserWithGroups(id: string): Promise<UserWithGroups | undefined> {
    const user = await this.getUser(id);
    if (!user) return undefined;

    try {
      const result = await db.execute(sql`
        SELECT 
          ug.user_id,
          ug.group_id,
          g.id as group_id_ref,
          g.name as group_name,
          g.color as group_color,
          g.created_at as group_created_at,
          g.updated_at as group_updated_at
        FROM user_groups ug
        INNER JOIN groups g ON ug.group_id = g.id
        WHERE ug.user_id = ${id}
      `);

      const userGroups = result.rows.map((row: any) => ({
        userId: row.user_id,
        groupId: row.group_id,
        group: {
          id: row.group_id_ref,
          name: row.group_name,
          color: row.group_color,
          createdAt: row.group_created_at,
          updatedAt: row.group_updated_at,
        }
      }));

      return { ...user, userGroups };
    } catch (error) {
      console.error('Error fetching user with groups:', error);
      return { ...user, userGroups: [] };
    }
  }

  async getUsers(): Promise<User[]> {
    return await db.select().from(users);
  }

  async createUser(userData: UpsertUser): Promise<User> {
    const [user] = await db.insert(users).values(userData).returning();
    return user;
  }

  async updateUser(id: string, userData: Partial<UpsertUser>): Promise<User> {
    const [user] = await db
      .update(users)
      .set({ ...userData, updatedAt: new Date() })
      .where(eq(users.id, id))
      .returning();
    return user;
  }

  async deleteUser(id: string): Promise<void> {
    await db.delete(users).where(eq(users.id, id));
  }

  // Group operations
  async getGroups(): Promise<Group[]> {
    return await db.select().from(groups).orderBy(groups.name);
  }

  async getGroup(id: number): Promise<Group | undefined> {
    const [group] = await db.select().from(groups).where(eq(groups.id, id));
    return group;
  }

  async createGroup(groupData: InsertGroup): Promise<Group> {
    const [group] = await db.insert(groups).values(groupData).returning();
    return group;
  }

  async updateGroup(id: number, groupData: Partial<InsertGroup>): Promise<Group> {
    const [group] = await db
      .update(groups)
      .set({ ...groupData, updatedAt: new Date() })
      .where(eq(groups.id, id))
      .returning();
    return group;
  }

  async deleteGroup(id: number): Promise<void> {
    await db.delete(groups).where(eq(groups.id, id));
  }

  // Supplier operations
  async getSuppliers(): Promise<Supplier[]> {
    return await db.select().from(suppliers).orderBy(suppliers.name);
  }

  async createSupplier(supplierData: InsertSupplier): Promise<Supplier> {
    const [supplier] = await db.insert(suppliers).values(supplierData).returning();
    return supplier;
  }

  async updateSupplier(id: number, supplierData: Partial<InsertSupplier>): Promise<Supplier> {
    const [supplier] = await db
      .update(suppliers)
      .set({ ...supplierData, updatedAt: new Date() })
      .where(eq(suppliers.id, id))
      .returning();
    return supplier;
  }

  async deleteSupplier(id: number): Promise<void> {
    await db.delete(suppliers).where(eq(suppliers.id, id));
  }

  // Order operations
  async getOrders(groupIds?: number[]): Promise<OrderWithRelations[]> {
    let query = db
      .select({
        id: orders.id,
        supplierId: orders.supplierId,
        groupId: orders.groupId,
        plannedDate: orders.plannedDate,
        status: orders.status,
        quantity: orders.quantity,
        unit: orders.unit,
        notes: orders.notes,
        createdBy: orders.createdBy,
        createdAt: orders.createdAt,
        updatedAt: orders.updatedAt,
        supplier: suppliers,
        group: groups,
      })
      .from(orders)
      .leftJoin(suppliers, eq(orders.supplierId, suppliers.id))
      .leftJoin(groups, eq(orders.groupId, groups.id));

    if (groupIds && groupIds.length > 0) {
      query = query.where(inArray(orders.groupId, groupIds));
    }

    return await query.orderBy(desc(orders.createdAt));
  }

  async getOrdersByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise<OrderWithRelations[]> {
    let query = db
      .select({
        id: orders.id,
        supplierId: orders.supplierId,
        groupId: orders.groupId,
        plannedDate: orders.plannedDate,
        status: orders.status,
        quantity: orders.quantity,
        unit: orders.unit,
        notes: orders.notes,
        createdBy: orders.createdBy,
        createdAt: orders.createdAt,
        updatedAt: orders.updatedAt,
        supplier: suppliers,
        group: groups,
      })
      .from(orders)
      .leftJoin(suppliers, eq(orders.supplierId, suppliers.id))
      .leftJoin(groups, eq(orders.groupId, groups.id))
      .where(
        and(
          gte(orders.plannedDate, startDate),
          lte(orders.plannedDate, endDate)
        )
      );

    if (groupIds && groupIds.length > 0) {
      query = query.where(
        and(
          gte(orders.plannedDate, startDate),
          lte(orders.plannedDate, endDate),
          inArray(orders.groupId, groupIds)
        )
      );
    }

    return await query.orderBy(desc(orders.plannedDate));
  }

  async getOrder(id: number): Promise<OrderWithRelations | undefined> {
    const [order] = await db
      .select({
        id: orders.id,
        supplierId: orders.supplierId,
        groupId: orders.groupId,
        plannedDate: orders.plannedDate,
        status: orders.status,
        quantity: orders.quantity,
        unit: orders.unit,
        notes: orders.notes,
        createdBy: orders.createdBy,
        createdAt: orders.createdAt,
        updatedAt: orders.updatedAt,
        supplier: suppliers,
        group: groups,
      })
      .from(orders)
      .leftJoin(suppliers, eq(orders.supplierId, suppliers.id))
      .leftJoin(groups, eq(orders.groupId, groups.id))
      .where(eq(orders.id, id));

    return order;
  }

  async createOrder(orderData: InsertOrder): Promise<Order> {
    const [order] = await db.insert(orders).values(orderData).returning();
    return order;
  }

  async updateOrder(id: number, orderData: Partial<InsertOrder>): Promise<Order> {
    const [order] = await db
      .update(orders)
      .set({ ...orderData, updatedAt: new Date() })
      .where(eq(orders.id, id))
      .returning();
    return order;
  }

  async deleteOrder(id: number): Promise<void> {
    await db.delete(orders).where(eq(orders.id, id));
  }

  // Delivery operations
  async getDeliveries(groupIds?: number[]): Promise<DeliveryWithRelations[]> {
    let query = db
      .select({
        id: deliveries.id,
        orderId: deliveries.orderId,
        supplierId: deliveries.supplierId,
        groupId: deliveries.groupId,
        scheduledDate: deliveries.scheduledDate,
        deliveredDate: deliveries.deliveredDate,
        status: deliveries.status,
        quantity: deliveries.quantity,
        unit: deliveries.unit,
        blNumber: deliveries.blNumber,
        blAmount: deliveries.blAmount,
        invoiceReference: deliveries.invoiceReference,
        invoiceAmount: deliveries.invoiceAmount,
        reconciled: deliveries.reconciled,
        validatedAt: deliveries.validatedAt,
        notes: deliveries.notes,
        createdBy: deliveries.createdBy,
        createdAt: deliveries.createdAt,
        updatedAt: deliveries.updatedAt,
        supplier: suppliers,
        group: groups,
      })
      .from(deliveries)
      .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id))
      .leftJoin(groups, eq(deliveries.groupId, groups.id));

    if (groupIds && groupIds.length > 0) {
      query = query.where(inArray(deliveries.groupId, groupIds));
    }

    return await query.orderBy(desc(deliveries.createdAt));
  }

  async getDeliveriesByDateRange(startDate: string, endDate: string, groupIds?: number[]): Promise<DeliveryWithRelations[]> {
    let query = db
      .select({
        id: deliveries.id,
        orderId: deliveries.orderId,
        supplierId: deliveries.supplierId,
        groupId: deliveries.groupId,
        scheduledDate: deliveries.scheduledDate,
        deliveredDate: deliveries.deliveredDate,
        status: deliveries.status,
        quantity: deliveries.quantity,
        unit: deliveries.unit,
        blNumber: deliveries.blNumber,
        blAmount: deliveries.blAmount,
        invoiceReference: deliveries.invoiceReference,
        invoiceAmount: deliveries.invoiceAmount,
        reconciled: deliveries.reconciled,
        validatedAt: deliveries.validatedAt,
        notes: deliveries.notes,
        createdBy: deliveries.createdBy,
        createdAt: deliveries.createdAt,
        updatedAt: deliveries.updatedAt,
        supplier: suppliers,
        group: groups,
      })
      .from(deliveries)
      .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id))
      .leftJoin(groups, eq(deliveries.groupId, groups.id))
      .where(
        and(
          gte(deliveries.scheduledDate, startDate),
          lte(deliveries.scheduledDate, endDate)
        )
      );

    if (groupIds && groupIds.length > 0) {
      query = query.where(
        and(
          gte(deliveries.scheduledDate, startDate),
          lte(deliveries.scheduledDate, endDate),
          inArray(deliveries.groupId, groupIds)
        )
      );
    }

    return await query.orderBy(desc(deliveries.scheduledDate));
  }

  async getDelivery(id: number): Promise<DeliveryWithRelations | undefined> {
    const [delivery] = await db
      .select({
        id: deliveries.id,
        orderId: deliveries.orderId,
        supplierId: deliveries.supplierId,
        groupId: deliveries.groupId,
        scheduledDate: deliveries.scheduledDate,
        deliveredDate: deliveries.deliveredDate,
        status: deliveries.status,
        quantity: deliveries.quantity,
        unit: deliveries.unit,
        blNumber: deliveries.blNumber,
        blAmount: deliveries.blAmount,
        invoiceReference: deliveries.invoiceReference,
        invoiceAmount: deliveries.invoiceAmount,
        reconciled: deliveries.reconciled,
        validatedAt: deliveries.validatedAt,
        notes: deliveries.notes,
        createdBy: deliveries.createdBy,
        createdAt: deliveries.createdAt,
        updatedAt: deliveries.updatedAt,
        supplier: suppliers,
        group: groups,
      })
      .from(deliveries)
      .leftJoin(suppliers, eq(deliveries.supplierId, suppliers.id))
      .leftJoin(groups, eq(deliveries.groupId, groups.id))
      .where(eq(deliveries.id, id));

    return delivery;
  }

  async createDelivery(deliveryData: InsertDelivery): Promise<Delivery> {
    const [delivery] = await db.insert(deliveries).values(deliveryData).returning();
    return delivery;
  }

  async updateDelivery(id: number, deliveryData: Partial<InsertDelivery>): Promise<Delivery> {
    const [delivery] = await db
      .update(deliveries)
      .set({ ...deliveryData, updatedAt: new Date() })
      .where(eq(deliveries.id, id))
      .returning();
    return delivery;
  }

  async deleteDelivery(id: number): Promise<void> {
    await db.delete(deliveries).where(eq(deliveries.id, id));
  }

  async validateDelivery(id: number, blData?: { blNumber: string; blAmount: number }): Promise<void> {
    const updateData: any = {
      status: 'delivered',
      deliveredDate: new Date().toISOString(),
      updatedAt: new Date(),
    };

    if (blData) {
      updateData.blNumber = blData.blNumber;
      if (blData.blAmount !== undefined) {
        updateData.blAmount = blData.blAmount.toString();
      }
    }

    await db.update(deliveries).set(updateData).where(eq(deliveries.id, id));
  }

  // User-Group operations
  async getUserGroups(userId: string): Promise<UserGroup[]> {
    return await db.select().from(userGroups).where(eq(userGroups.userId, userId));
  }

  async assignUserToGroup(userGroupData: InsertUserGroup): Promise<UserGroup> {
    const [userGroup] = await db.insert(userGroups).values(userGroupData).returning();
    return userGroup;
  }

  async removeUserFromGroup(userId: string, groupId: number): Promise<void> {
    await db.delete(userGroups).where(
      and(eq(userGroups.userId, userId), eq(userGroups.groupId, groupId))
    );
  }

  // Statistics
  async getMonthlyStats(year: number, month: number, groupIds?: number[]): Promise<{
    ordersCount: number;
    deliveriesCount: number;
    pendingOrdersCount: number;
    averageDeliveryTime: number;
    totalPalettes: number;
    totalPackages: number;
  }> {
    // En mode développement avec MemStorage, retourner des statistiques simulées
    if (process.env.NODE_ENV === 'development') {
      console.log('📊 Mode développement - statistiques simulées');
      return {
        ordersCount: 12,
        deliveriesCount: 8,
        pendingOrdersCount: 3,
        averageDeliveryTime: 2.5,
        totalPalettes: 45,
        totalPackages: 156,
      };
    }

    // En production, calculer les vraies statistiques
    const startDate = `${year}-${month.toString().padStart(2, '0')}-01`;
    const endDate = month === 12 
      ? `${year + 1}-01-01` 
      : `${year}-${(month + 1).toString().padStart(2, '0')}-01`;

    try {
      console.log('📊 Calcul statistiques mensuelles:', { year, month, startDate, endDate, groupIds });

      // Construire les conditions pour le filtrage par groupe
      let ordersWhereCondition = and(
        gte(orders.plannedDate, new Date(startDate)),
        lt(orders.plannedDate, new Date(endDate))
      );
      let deliveriesWhereCondition = and(
        gte(deliveries.plannedDate, new Date(startDate)), 
        lt(deliveries.plannedDate, new Date(endDate))
      );

      // Ajouter le filtre par groupe si spécifié
      if (groupIds && groupIds.length > 0) {
        ordersWhereCondition = and(ordersWhereCondition, inArray(orders.groupId, groupIds));
        deliveriesWhereCondition = and(deliveriesWhereCondition, inArray(deliveries.groupId, groupIds));
      }

      // Compter les commandes du mois
      const ordersResult = await db
        .select({ count: sql<number>`count(*)` })
        .from(orders)
        .where(ordersWhereCondition);

      // Compter les livraisons du mois
      const deliveriesResult = await db
        .select({ count: sql<number>`count(*)` })
        .from(deliveries)
        .where(deliveriesWhereCondition);

      // Commandes en attente (sans date de livraison ou pas encore livrées)
      let pendingWhereCondition = or(
        isNull(orders.plannedDate),
        eq(orders.status, 'pending')
      );
      if (groupIds && groupIds.length > 0) {
        pendingWhereCondition = and(pendingWhereCondition, inArray(orders.groupId, groupIds));
      }

      const pendingResult = await db
        .select({ count: sql<number>`count(*)` })
        .from(orders)
        .where(pendingWhereCondition);

      // Calculer les totaux de palettes et colis du mois
      const deliveriesStatsResult = await db
        .select({
          totalPalettes: sql<number>`COALESCE(SUM(CAST(${deliveries.quantity} as INTEGER)), 0)`,
          totalPackages: sql<number>`COALESCE(COUNT(*), 0)`,
          avgDelay: sql<number>`COALESCE(AVG(EXTRACT(DAY FROM (${deliveries.actualDate} - ${deliveries.plannedDate}))), 0)`
        })
        .from(deliveries)
        .where(and(
          deliveriesWhereCondition,
          isNotNull(deliveries.actualDate)
        ));

      const ordersCount = Number(ordersResult[0]?.count || 0);
      const deliveriesCount = Number(deliveriesResult[0]?.count || 0);
      const pendingOrdersCount = Number(pendingResult[0]?.count || 0);
      const totalPalettes = Number(deliveriesStatsResult[0]?.totalPalettes || 0);
      const totalPackages = Number(deliveriesStatsResult[0]?.totalPackages || 0);
      const averageDeliveryTime = Number(deliveriesStatsResult[0]?.avgDelay || 0);

      console.log('📊 Statistiques calculées:', {
        ordersCount,
        deliveriesCount,
        pendingOrdersCount,
        averageDeliveryTime,
        totalPalettes,
        totalPackages,
      });

      return {
        ordersCount,
        deliveriesCount,
        pendingOrdersCount,
        averageDeliveryTime,
        totalPalettes,
        totalPackages,
      };

    } catch (error) {
      console.error('❌ Erreur calcul statistiques:', error);
      // Retourner des zéros en cas d'erreur pour éviter un crash
      return {
        ordersCount: 0,
        deliveriesCount: 0,
        pendingOrdersCount: 0,
        averageDeliveryTime: 0,
        totalPalettes: 0,
        totalPackages: 0,
      };
    }
  }

  // Publicity operations
  async getPublicities(year?: number, groupIds?: number[]): Promise<PublicityWithRelations[]> {
    let query = db
      .select({
        id: publicities.id,
        pubNumber: publicities.pubNumber,
        designation: publicities.designation,
        startDate: publicities.startDate,
        endDate: publicities.endDate,
        year: publicities.year,
        createdBy: publicities.createdBy,
        createdAt: publicities.createdAt,
        updatedAt: publicities.updatedAt,
      })
      .from(publicities);

    if (year) {
      query = query.where(eq(publicities.year, year));
    }

    const results = await query.orderBy(desc(publicities.createdAt));

    const publicityIds = results.map((p: any) => p.id);
    const participations = publicityIds.length > 0 
      ? await db
          .select({
            publicityId: publicityParticipations.publicityId,
            groupId: publicityParticipations.groupId,
            group: groups,
          })
          .from(publicityParticipations)
          .leftJoin(groups, eq(publicityParticipations.groupId, groups.id))
          .where(inArray(publicityParticipations.publicityId, publicityIds))
      : [];

    return results.map((publicity: any) => ({
      ...publicity,
      participations: participations
        .filter((p) => p.publicityId === publicity.id)
        .map((p) => ({
          publicityId: p.publicityId,
          groupId: p.groupId,
          group: p.group!,
        })),
    }));
  }

  async getPublicity(id: number): Promise<PublicityWithRelations | undefined> {
    const [publicity] = await db.select().from(publicities).where(eq(publicities.id, id));
    if (!publicity) return undefined;

    const participations = await db
      .select({
        publicityId: publicityParticipations.publicityId,
        groupId: publicityParticipations.groupId,
        group: groups,
      })
      .from(publicityParticipations)
      .leftJoin(groups, eq(publicityParticipations.groupId, groups.id))
      .where(eq(publicityParticipations.publicityId, id));

    return {
      ...publicity,
      participations: participations.map(p => ({
        publicityId: p.publicityId,
        groupId: p.groupId,
        group: p.group!,
      })),
    };
  }

  async createPublicity(publicityData: InsertPublicity): Promise<Publicity> {
    const [publicity] = await db.insert(publicities).values(publicityData).returning();
    return publicity;
  }

  async updatePublicity(id: number, publicityData: Partial<InsertPublicity>): Promise<Publicity> {
    const [publicity] = await db
      .update(publicities)
      .set({ ...publicityData, updatedAt: new Date() })
      .where(eq(publicities.id, id))
      .returning();
    return publicity;
  }

  async deletePublicity(id: number): Promise<void> {
    await db.delete(publicityParticipations).where(eq(publicityParticipations.publicityId, id));
    await db.delete(publicities).where(eq(publicities.id, id));
  }

  async getPublicityParticipations(publicityId: number): Promise<PublicityParticipation[]> {
    return await db
      .select()
      .from(publicityParticipations)
      .where(eq(publicityParticipations.publicityId, publicityId));
  }

  async setPublicityParticipations(publicityId: number, groupIds: number[]): Promise<void> {
    await db.delete(publicityParticipations).where(eq(publicityParticipations.publicityId, publicityId));

    if (groupIds.length > 0) {
      const participationsData = groupIds.map(groupId => ({
        publicityId,
        groupId,
      }));
      await db.insert(publicityParticipations).values(participationsData);
    }
  }

  // NocoDB Configuration operations
  async getNocodbConfigs(): Promise<NocodbConfig[]> {
    return await db.select().from(nocodbConfig).orderBy(desc(nocodbConfig.createdAt));
  }

  async getNocodbConfig(id: number): Promise<NocodbConfig | undefined> {
    const [config] = await db.select().from(nocodbConfig).where(eq(nocodbConfig.id, id));
    return config;
  }

  async getActiveNocodbConfig(): Promise<NocodbConfig | undefined> {
    try {
      const [config] = await db
        .select()
        .from(nocodbConfig)
        .where(eq(nocodbConfig.isActive, true))
        .limit(1);
      
      console.log('🔧 Configuration NocoDB active récupérée:', config);
      return config;
    } catch (error) {
      console.error('❌ Erreur récupération config NocoDB:', error);
      return undefined;
    }
  }

  async createNocodbConfig(configData: InsertNocodbConfig): Promise<NocodbConfig> {
    const [config] = await db.insert(nocodbConfig).values(configData).returning();
    return config;
  }

  async updateNocodbConfig(id: number, configData: Partial<InsertNocodbConfig>): Promise<NocodbConfig> {
    const [config] = await db
      .update(nocodbConfig)
      .set({ ...configData, updatedAt: new Date() })
      .where(eq(nocodbConfig.id, id))
      .returning();
    return config;
  }

  async deleteNocodbConfig(id: number): Promise<void> {
    await db.delete(nocodbConfig).where(eq(nocodbConfig.id, id));
  }

  // Invoice Verification Cache operations
  async getInvoiceVerificationCache(cacheKey: string): Promise<InvoiceVerificationCache | undefined> {
    const [cache] = await db
      .select()
      .from(invoiceVerificationCache)
      .where(eq(invoiceVerificationCache.cacheKey, cacheKey));
    return cache;
  }

  async createInvoiceVerificationCache(cacheData: InsertInvoiceVerificationCache): Promise<InvoiceVerificationCache> {
    const [cache] = await db.insert(invoiceVerificationCache).values(cacheData).returning();
    return cache;
  }

  async clearExpiredCache(): Promise<void> {
    await db.delete(invoiceVerificationCache).where(
      sql`expires_at < NOW()`
    );
  }

  // Placeholder implementations for other operations
  async getCustomerOrders(): Promise<CustomerOrderWithRelations[]> { return []; }
  async getCustomerOrder(): Promise<CustomerOrderWithRelations | undefined> { return undefined; }
  async createCustomerOrder(): Promise<CustomerOrder> { return {} as CustomerOrder; }
  async updateCustomerOrder(): Promise<CustomerOrder> { return {} as CustomerOrder; }
  async deleteCustomerOrder(): Promise<void> {}

  async getDlcProducts(): Promise<DlcProductWithRelations[]> { return []; }
  async getDlcProduct(): Promise<DlcProductWithRelations | undefined> { return undefined; }
  async createDlcProduct(): Promise<DlcProductFrontend> { return {} as DlcProductFrontend; }
  async updateDlcProduct(): Promise<DlcProductFrontend> { return {} as DlcProductFrontend; }
  async deleteDlcProduct(): Promise<void> {}
  async validateDlcProduct(): Promise<DlcProductFrontend> { return {} as DlcProductFrontend; }
  async getDlcStats(): Promise<{ active: number; expiringSoon: number; expired: number; }> { 
    return { active: 0, expiringSoon: 0, expired: 0 }; 
  }

  async getTasks(): Promise<any[]> { return []; }
  async getTask(): Promise<any | undefined> { return undefined; }
  async createTask(): Promise<Task> { return {} as Task; }
  async updateTask(): Promise<Task> { return {} as Task; }
  async deleteTask(): Promise<void> {}
  async completeTask(): Promise<void> {}
}

// MemStorage class for development
export class MemStorage implements IStorage {
  private users = new Map<string, User>();
  private groups = new Map<number, Group>();
  private suppliers = new Map<number, Supplier>();
  private orders = new Map<number, Order>();
  private deliveries = new Map<number, Delivery>();
  private userGroups = new Map<string, UserGroup[]>();
  private publicities = new Map<number, Publicity>();
  private publicityParticipations = new Map<number, PublicityParticipation[]>();
  private customerOrders = new Map<number, CustomerOrder>();
  private dlcProducts = new Map<number, DlcProduct>();
  private tasks = new Map<number, Task>();

  private idCounters = {
    group: 1,
    supplier: 1,
    order: 1,
    delivery: 1,
    publicity: 1,
    customerOrder: 1,
    dlcProduct: 1,
    task: 1,
  };

  constructor() {
    this.initializeTestData();
  }

  private initializeTestData() {
    // Create admin user
    const adminUser: User = {
      id: 'admin',
      username: 'admin',
      email: 'admin@example.com',
      name: 'Admin',
      firstName: 'Admin',
      lastName: 'User',
      profileImageUrl: null,
      password: 'admin', // In real app, this would be hashed
      role: 'admin',
      passwordChanged: false,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    this.users.set(adminUser.id, adminUser);

    // Create test groups
    const testGroup: Group = {
      id: 1,
      name: 'Magasin Test',
      color: '#3B82F6',
      nocodbConfigId: null,
      nocodbTableName: null,
      invoiceColumnName: null,
      nocodbBlColumnName: null,
      nocodbAmountColumnName: null,
      nocodbSupplierColumnName: null,
      webhookUrl: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    this.groups.set(testGroup.id, testGroup);
    this.idCounters.group = 2;

    // Create test supplier
    const testSupplier: Supplier = {
      id: 1,
      name: 'Fournisseur Test',
      contact: 'test@supplier.com',
      phone: '0123456789',
      hasDlc: false,
      automaticReconciliation: false,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    this.suppliers.set(testSupplier.id, testSupplier);
    this.idCounters.supplier = 2;

    console.log('✅ MemStorage initialized with admin user (admin/admin)');
  }

  // User operations
  async getUser(id: string): Promise<User | undefined> {
    return this.users.get(id);
  }

  async getUserByEmail(email: string): Promise<User | undefined> {
    for (const user of this.users.values()) {
      if (user.email === email) return user;
    }
    return undefined;
  }

  async getUserByUsername(username: string): Promise<User | undefined> {
    for (const user of this.users.values()) {
      if (user.username === username) return user;
    }
    return undefined;
  }

  async upsertUser(userData: UpsertUser): Promise<User> {
    const existingUser = this.users.get(userData.id);
    const user: User = {
      id: userData.id,
      username: userData.username,
      email: userData.email || null,
      name: userData.name || null,
      firstName: userData.firstName || null,
      lastName: userData.lastName || null,
      profileImageUrl: userData.profileImageUrl || null,
      password: userData.password || null,
      role: userData.role,
      passwordChanged: userData.passwordChanged || false,
      createdAt: existingUser?.createdAt || new Date(),
      updatedAt: new Date(),
    };
    this.users.set(user.id, user);
    return user;
  }

  async getUserWithGroups(id: string): Promise<UserWithGroups | undefined> {
    const user = await this.getUser(id);
    if (!user) return undefined;

    const userGroupsList = this.userGroups.get(id) || [];
    const userGroupsWithGroups = userGroupsList.map(ug => ({
      ...ug,
      group: this.groups.get(ug.groupId)!,
    }));

    return { ...user, userGroups: userGroupsWithGroups };
  }

  async getUsers(): Promise<User[]> {
    return Array.from(this.users.values());
  }

  async createUser(userData: UpsertUser): Promise<User> {
    return this.upsertUser(userData);
  }

  async updateUser(id: string, userData: Partial<UpsertUser>): Promise<User> {
    const existingUser = this.users.get(id);
    if (!existingUser) throw new Error('User not found');
    
    const updatedUser = { ...existingUser, ...userData, updatedAt: new Date() };
    this.users.set(id, updatedUser);
    return updatedUser;
  }

  async deleteUser(id: string): Promise<void> {
    this.users.delete(id);
    this.userGroups.delete(id);
  }

  // Group operations
  async getGroups(): Promise<Group[]> {
    return Array.from(this.groups.values());
  }

  async getGroup(id: number): Promise<Group | undefined> {
    return this.groups.get(id);
  }

  async createGroup(groupData: InsertGroup): Promise<Group> {
    const id = this.idCounters.group++;
    const group: Group = {
      id,
      name: groupData.name,
      color: groupData.color || null,
      nocodbConfigId: groupData.nocodbConfigId || null,
      nocodbTableName: groupData.nocodbTableName || null,
      invoiceColumnName: groupData.invoiceColumnName || null,
      nocodbBlColumnName: groupData.nocodbBlColumnName || null,
      nocodbAmountColumnName: groupData.nocodbAmountColumnName || null,
      nocodbSupplierColumnName: groupData.nocodbSupplierColumnName || null,
      webhookUrl: groupData.webhookUrl || null,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    this.groups.set(id, group);
    return group;
  }

  async updateGroup(id: number, groupData: Partial<InsertGroup>): Promise<Group> {
    const existingGroup = this.groups.get(id);
    if (!existingGroup) throw new Error('Group not found');
    
    const updatedGroup = { ...existingGroup, ...groupData, updatedAt: new Date() };
    this.groups.set(id, updatedGroup);
    return updatedGroup;
  }

  async deleteGroup(id: number): Promise<void> {
    this.groups.delete(id);
  }

  // Supplier operations
  async getSuppliers(): Promise<Supplier[]> {
    return Array.from(this.suppliers.values());
  }

  async createSupplier(supplierData: InsertSupplier): Promise<Supplier> {
    const id = this.idCounters.supplier++;
    const supplier: Supplier = {
      id,
      name: supplierData.name,
      contact: supplierData.contact || null,
      phone: supplierData.phone || null,
      hasDlc: supplierData.hasDlc || null,
      automaticReconciliation: supplierData.automaticReconciliation || null,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    this.suppliers.set(id, supplier);
    return supplier;
  }

  async updateSupplier(id: number, supplierData: Partial<InsertSupplier>): Promise<Supplier> {
    const existingSupplier = this.suppliers.get(id);
    if (!existingSupplier) throw new Error('Supplier not found');
    
    const updatedSupplier = { ...existingSupplier, ...supplierData, updatedAt: new Date() };
    this.suppliers.set(id, updatedSupplier);
    return updatedSupplier;
  }

  async deleteSupplier(id: number): Promise<void> {
    this.suppliers.delete(id);
  }

  // NocoDB Configuration methods
  async getNocodbConfigs(): Promise<NocodbConfig[]> {
    return []; // Empty array for development
  }

  async getNocodbConfig(id: number): Promise<NocodbConfig | undefined> {
    return undefined; // Not found in development
  }

  async getActiveNocodbConfig(): Promise<NocodbConfig | undefined> {
    // En développement, créer une config de test
    const testConfig: NocodbConfig = {
      id: 1,
      name: 'Configuration Test NocoDB',
      baseUrl: 'https://nocodb-test.example.com',
      projectId: 'test-project-id',
      apiToken: 'test-api-token-123',
      description: 'Configuration de test pour vérification des factures',
      isActive: true,
      createdBy: 'admin',
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    
    console.log('🔧 Retour config NocoDB test:', testConfig);
    return testConfig;
  }

  async createNocodbConfig(config: InsertNocodbConfig): Promise<NocodbConfig> {
    const newConfig: NocodbConfig = {
      id: 1,
      name: config.name,
      baseUrl: config.baseUrl,
      projectId: config.projectId,
      apiToken: config.apiToken,
      description: config.description || null,
      isActive: config.isActive ?? true,
      createdBy: config.createdBy || null,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    return newConfig;
  }

  async updateNocodbConfig(id: number, config: Partial<InsertNocodbConfig>): Promise<NocodbConfig> {
    const updatedConfig: NocodbConfig = {
      id,
      name: config.name || 'Test Config',
      baseUrl: config.baseUrl || 'https://nocodb.example.com',
      projectId: config.projectId || 'test-project',
      apiToken: config.apiToken || 'test-token',
      description: config.description || null,
      isActive: config.isActive ?? true,
      createdBy: config.createdBy || null,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    return updatedConfig;
  }

  async deleteNocodbConfig(id: number): Promise<void> {
    // No-op in development
  }

  async getInvoiceVerificationCache(cacheKey: string): Promise<InvoiceVerificationCache | undefined> {
    return undefined; // Pas de cache en développement
  }

  async createInvoiceVerificationCache(cache: InsertInvoiceVerificationCache): Promise<InvoiceVerificationCache> {
    const newCache: InvoiceVerificationCache = {
      id: 1,
      cacheKey: cache.cacheKey,
      groupId: cache.groupId,
      invoiceReference: cache.invoiceReference,
      supplierName: cache.supplierName || null,
      exists: cache.exists,
      matchType: cache.matchType,
      errorMessage: cache.errorMessage || null,
      cacheHit: cache.cacheHit || false,
      apiCallTime: cache.apiCallTime || null,
      expiresAt: cache.expiresAt,
      createdAt: new Date(),
      updatedAt: new Date(),
    };
    return newCache;
  }

  async clearExpiredCache(): Promise<void> {
    // No-op en développement
  }

  // Placeholder implementations for remaining methods
  async getOrders(): Promise<OrderWithRelations[]> { return []; }
  async getOrdersByDateRange(): Promise<OrderWithRelations[]> { return []; }
  async getOrder(): Promise<OrderWithRelations | undefined> { return undefined; }
  async createOrder(): Promise<Order> { return {} as Order; }
  async updateOrder(): Promise<Order> { return {} as Order; }
  async deleteOrder(): Promise<void> {}

  async getDeliveries(): Promise<DeliveryWithRelations[]> { return []; }
  async getDeliveriesByDateRange(): Promise<DeliveryWithRelations[]> { return []; }
  async getDelivery(): Promise<DeliveryWithRelations | undefined> { return undefined; }
  async createDelivery(): Promise<Delivery> { return {} as Delivery; }
  async updateDelivery(): Promise<Delivery> { return {} as Delivery; }
  async deleteDelivery(): Promise<void> {}
  async validateDelivery(): Promise<void> {}

  async getUserGroups(): Promise<UserGroup[]> { return []; }
  async assignUserToGroup(): Promise<UserGroup> { return {} as UserGroup; }
  async removeUserFromGroup(): Promise<void> {}

  async getMonthlyStats(): Promise<any> { return {}; }

  async getPublicities(): Promise<PublicityWithRelations[]> { return []; }
  async getPublicity(): Promise<PublicityWithRelations | undefined> { return undefined; }
  async createPublicity(): Promise<Publicity> { return {} as Publicity; }
  async updatePublicity(): Promise<Publicity> { return {} as Publicity; }
  async deletePublicity(): Promise<void> {}
  async getPublicityParticipations(): Promise<PublicityParticipation[]> { return []; }
  async setPublicityParticipations(): Promise<void> {}

  async getCustomerOrders(): Promise<CustomerOrderWithRelations[]> { return []; }
  async getCustomerOrder(): Promise<CustomerOrderWithRelations | undefined> { return undefined; }
  async createCustomerOrder(): Promise<CustomerOrder> { return {} as CustomerOrder; }
  async updateCustomerOrder(): Promise<CustomerOrder> { return {} as CustomerOrder; }
  async deleteCustomerOrder(): Promise<void> {}

  async getDlcProducts(): Promise<DlcProductWithRelations[]> { return []; }
  async getDlcProduct(): Promise<DlcProductWithRelations | undefined> { return undefined; }
  async createDlcProduct(): Promise<DlcProductFrontend> { return {} as DlcProductFrontend; }
  async updateDlcProduct(): Promise<DlcProductFrontend> { return {} as DlcProductFrontend; }
  async deleteDlcProduct(): Promise<void> {}
  async validateDlcProduct(): Promise<DlcProductFrontend> { return {} as DlcProductFrontend; }
  async getDlcStats(): Promise<{ active: number; expiringSoon: number; expired: number; }> { 
    return { active: 0, expiringSoon: 0, expired: 0 }; 
  }

  async getTasks(): Promise<any[]> { return []; }
  async getTask(): Promise<any | undefined> { return undefined; }
  async createTask(): Promise<Task> { return {} as Task; }
  async updateTask(): Promise<Task> { return {} as Task; }
  async deleteTask(): Promise<void> {}
  async completeTask(): Promise<void> {}
}

// Use MemStorage in development, DatabaseStorage in production
const isProduction = process.env.NODE_ENV === 'production';
export const storage: IStorage = isProduction ? new DatabaseStorage() : new MemStorage();