car_mms/app/lib/car-dataset-management.server.ts

import { prisma } from "~/lib/db.server";
import type { CreateCarDatasetData, UpdateCarDatasetData } from "~/types/database";

// Get all unique manufacturers
export async function getManufacturers() {
  try {
    const manufacturers = await prisma.carDataset.findMany({
      where: { isActive: true },
      select: { manufacturer: true },
      distinct: ['manufacturer'],
      orderBy: { manufacturer: 'asc' },
    });

    return manufacturers.map(item => item.manufacturer);
  } catch (error) {
    console.error("Error fetching manufacturers:", error);
    throw new Error("فشل في جلب الشركات المصنعة");
  }
}

// Get all models for a specific manufacturer
export async function getModelsByManufacturer(manufacturer: string) {
  try {
    const models = await prisma.carDataset.findMany({
      where: { 
        manufacturer,
        isActive: true 
      },
      select: { model: true, bodyType: true },
      orderBy: { model: 'asc' },
    });

    return models;
  } catch (error) {
    console.error("Error fetching models:", error);
    throw new Error("فشل في جلب الموديلات");
  }
}

// Get body type for a specific manufacturer and model
export async function getBodyType(manufacturer: string, model: string) {
  try {
    const carData = await prisma.carDataset.findFirst({
      where: { 
        manufacturer,
        model,
        isActive: true 
      },
      select: { bodyType: true },
    });

    return carData?.bodyType || null;
  } catch (error) {
    console.error("Error fetching body type:", error);
    throw new Error("فشل في جلب نوع الهيكل");
  }
}

// Get all car dataset entries with pagination
export async function getCarDataset(
  searchQuery: string = "",
  page: number = 1,
  limit: number = 50,
  manufacturer?: string
) {
  try {
    const offset = (page - 1) * limit;

    const where = {
      AND: [
        manufacturer ? { manufacturer } : {},
        searchQuery ? {
          OR: [
            { manufacturer: { contains: searchQuery, mode: 'insensitive' as const } },
            { model: { contains: searchQuery, mode: 'insensitive' as const } },
            { bodyType: { contains: searchQuery, mode: 'insensitive' as const } },
          ]
        } : {}
      ]
    };

    const [carDataset, total] = await Promise.all([
      prisma.carDataset.findMany({
        where,
        orderBy: [
          { manufacturer: 'asc' },
          { model: 'asc' }
        ],
        skip: offset,
        take: limit,
      }),
      prisma.carDataset.count({ where })
    ]);

    const totalPages = Math.ceil(total / limit);

    return {
      carDataset,
      total,
      totalPages,
    };
  } catch (error) {
    console.error("Error fetching car dataset:", error);
    throw new Error("فشل في جلب بيانات السيارات");
  }
}

// Create a new car dataset entry
export async function createCarDataset(data: CreateCarDatasetData) {
  try {
    const carDataset = await prisma.carDataset.create({
      data: {
        manufacturer: data.manufacturer.trim(),
        model: data.model.trim(),
        bodyType: data.bodyType.trim(),
        isActive: data.isActive ?? true,
      },
    });

    return { success: true, carDataset };
  } catch (error: any) {
    console.error("Error creating car dataset:", error);
    
    if (error.code === 'P2002') {
      return { 
        success: false, 
        error: "هذا الموديل موجود بالفعل لهذه الشركة المصنعة" 
      };
    }
    
    return { 
      success: false, 
      error: "فشل في إنشاء بيانات السيارة" 
    };
  }
}

// Update a car dataset entry
export async function updateCarDataset(id: number, data: UpdateCarDatasetData) {
  try {
    const carDataset = await prisma.carDataset.update({
      where: { id },
      data: {
        ...(data.manufacturer && { manufacturer: data.manufacturer.trim() }),
        ...(data.model && { model: data.model.trim() }),
        ...(data.bodyType && { bodyType: data.bodyType.trim() }),
        ...(data.isActive !== undefined && { isActive: data.isActive }),
      },
    });

    return { success: true, carDataset };
  } catch (error: any) {
    console.error("Error updating car dataset:", error);
    
    if (error.code === 'P2002') {
      return { 
        success: false, 
        error: "هذا الموديل موجود بالفعل لهذه الشركة المصنعة" 
      };
    }
    
    if (error.code === 'P2025') {
      return { 
        success: false, 
        error: "بيانات السيارة غير موجودة" 
      };
    }
    
    return { 
      success: false, 
      error: "فشل في تحديث بيانات السيارة" 
    };
  }
}

// Delete a car dataset entry
export async function deleteCarDataset(id: number) {
  try {
    await prisma.carDataset.delete({
      where: { id },
    });

    return { success: true };
  } catch (error: any) {
    console.error("Error deleting car dataset:", error);
    
    if (error.code === 'P2025') {
      return { 
        success: false, 
        error: "بيانات السيارة غير موجودة" 
      };
    }
    
    return { 
      success: false, 
      error: "فشل في حذف بيانات السيارة" 
    };
  }
}

// Get car dataset entry by ID
export async function getCarDatasetById(id: number) {
  try {
    const carDataset = await prisma.carDataset.findUnique({
      where: { id },
    });

    return carDataset;
  } catch (error) {
    console.error("Error fetching car dataset by ID:", error);
    throw new Error("فشل في جلب بيانات السيارة");
  }
}

// Bulk import car dataset
export async function bulkImportCarDataset(data: CreateCarDatasetData[]) {
  try {
    const results = await prisma.$transaction(async (tx) => {
      const created = [];
      const errors = [];

      for (const item of data) {
        try {
          const carDataset = await tx.carDataset.create({
            data: {
              manufacturer: item.manufacturer.trim(),
              model: item.model.trim(),
              bodyType: item.bodyType.trim(),
              isActive: item.isActive ?? true,
            },
          });
          created.push(carDataset);
        } catch (error: any) {
          if (error.code === 'P2002') {
            errors.push(`${item.manufacturer} ${item.model} - موجود بالفعل`);
          } else {
            errors.push(`${item.manufacturer} ${item.model} - خطأ غير معروف`);
          }
        }
      }

      return { created, errors };
    });

    return { 
      success: true, 
      created: results.created.length,
      errors: results.errors 
    };
  } catch (error) {
    console.error("Error bulk importing car dataset:", error);
    return { 
      success: false, 
      error: "فشل في استيراد بيانات السيارات" 
    };
  }
}