import { db } from '../db/db_index';
import { storeInfo, productInfo } from '../db/schema';
import { eq, inArray } from 'drizzle-orm';

export interface Store {
  id: number;
  name: string;
  description: string | null;
  imageUrl: string | null;
  owner: number;
  createdAt: Date;
  // updatedAt: Date;
}

export async function getAllStores(): Promise<any[]> {
  const stores = await db.query.storeInfo.findMany({
    with: {
      owner: true,
    },
  });

  return stores;
}

export async function getStoreById(id: number): Promise<any | null> {
  const store = await db.query.storeInfo.findFirst({
    where: eq(storeInfo.id, id),
    with: {
      owner: true,
    },
  });

  return store || null;
}

export interface CreateStoreInput {
  name: string;
  description?: string;
  imageUrl?: string;
  owner: number;
}

export async function createStore(
  input: CreateStoreInput,
  products?: number[]
): Promise<Store> {
  const [newStore] = await db
    .insert(storeInfo)
    .values({
      name: input.name,
      description: input.description,
      imageUrl: input.imageUrl,
      owner: input.owner,
    })
    .returning();

  if (products && products.length > 0) {
    await db
      .update(productInfo)
      .set({ storeId: newStore.id })
      .where(inArray(productInfo.id, products));
  }

  return {
    id: newStore.id,
    name: newStore.name,
    description: newStore.description,
    imageUrl: newStore.imageUrl,
    owner: newStore.owner,
    createdAt: newStore.createdAt,
    // updatedAt: newStore.updatedAt,
  };
}

export interface UpdateStoreInput {
  name?: string;
  description?: string;
  imageUrl?: string;
  owner?: number;
}

export async function updateStore(
  id: number,
  input: UpdateStoreInput,
  products?: number[]
): Promise<Store> {
  const [updatedStore] = await db
    .update(storeInfo)
    .set({
      ...input,
      // updatedAt: new Date(),
    })
    .where(eq(storeInfo.id, id))
    .returning();

  if (!updatedStore) {
    throw new Error("Store not found");
  }

  if (products !== undefined) {
    await db
      .update(productInfo)
      .set({ storeId: null })
      .where(eq(productInfo.storeId, id));

    if (products.length > 0) {
      await db
        .update(productInfo)
        .set({ storeId: id })
        .where(inArray(productInfo.id, products));
    }
  }

  return {
    id: updatedStore.id,
    name: updatedStore.name,
    description: updatedStore.description,
    imageUrl: updatedStore.imageUrl,
    owner: updatedStore.owner,
    createdAt: updatedStore.createdAt,
    // updatedAt: updatedStore.updatedAt,
  };
}

export async function deleteStore(id: number): Promise<{ message: string }> {
  return await db.transaction(async (tx) => {
    await tx
      .update(productInfo)
      .set({ storeId: null })
      .where(eq(productInfo.storeId, id));

    const [deletedStore] = await tx
      .delete(storeInfo)
      .where(eq(storeInfo.id, id))
      .returning();

    if (!deletedStore) {
      throw new Error("Store not found");
    }

    return {
      message: "Store deleted successfully",
    };
  });
}