// BrandService.js
const {
  getAllBrandsDb,
  getBrandByIdDb,
  getBrandByNameDb,
  createBrandDb,
  updateBrandDb,
  deleteBrandDb,
  checkBrandNameExistsDb,
} = require('../db/brand.db');

const {
  getErrorCodesByBrandIdDb,
  createErrorCodeDb,
  updateErrorCodeDb,
  deleteErrorCodeDb,
} = require('../db/brand_code.db');

const {
  getSparePartnsByErrorCodeIdDb,
  createSparePartDb,
  updateSparePartDb,
  deleteSparePartDb,
} = require('../db/brand_sparepart.db');

const {
  getSolutionsByErrorCodeIdDb,
  createSolutionDb,
  updateSolutionDb,
  deleteSolutionDb,
} = require('../db/brand_code_solution.db');

const { getFileUploadByPathDb } = require('../db/file_uploads.db');
const { ErrorHandler } = require('../helpers/error');

class BrandService {
  static async getAllBrands(param) {
    try {
      const results = await getAllBrandsDb(param);
      return results;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message || 'Failed to get brands');
    }
  }

  static async getBrandById(id) {
    try {
      const brand = await getBrandByIdDb(id);
      if (!brand) throw new ErrorHandler(404, 'Brand not found');

      const errorCodes = await getErrorCodesByBrandIdDb(brand.brand_id) || [];

      const errorCodesWithDetails = await Promise.all(
        errorCodes.map(async (errorCode) => {
          const solutions = (await getSolutionsByErrorCodeIdDb(errorCode.error_code_id)) || [];
          const solutionsWithFile = await Promise.all(
            solutions.map(async (s) => {
              let fileData = null;
              if (s.path_solution && s.type_solution && s.type_solution !== 'text') {
                try {
                  fileData = await getFileUploadByPathDb(s.path_solution);
                } catch (e) {
                  fileData = null;
                }
              }
              return {
                ...s,
                file_upload_name: fileData?.file_upload_name || null,
                path_document: fileData?.path_document || null
              };
            })
          );

          const spareparts = (await getSparePartnsByErrorCodeIdDb(errorCode.error_code_id)) || [];

          return {
            ...errorCode,
            solution: solutionsWithFile,
            sparepart: spareparts
          };
        })
      );

      return {
        ...brand,
        error_code: errorCodesWithDetails
      };
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message || 'Failed to get brand detail');
    }
  }

  static async createBrandWithFullData(data) {
    try {
      if (!data || typeof data !== 'object') data = {};

      if (!data.brand_name) throw new ErrorHandler(400, 'brand_name is required');
      const exists = await checkBrandNameExistsDb(data.brand_name);
      if (exists) throw new ErrorHandler(400, 'Brand name already exists');

      if (!Array.isArray(data.error_code) || data.error_code.length === 0) {
        throw new ErrorHandler(400, 'Brand must have at least 1 error code with solution');
      }

      for (const ec of data.error_code) {
        if (!Array.isArray(ec.solution) || ec.solution.length === 0) {
          throw new ErrorHandler(400, `Error code ${ec.error_code} must have at least 1 solution`);
        }
      }

      const brandData = {
        brand_name: data.brand_name,
        brand_type: data.brand_type || null,
        brand_manufacture: data.brand_manufacture || null,
        brand_model: data.brand_model || null,
        is_active: data.is_active,
        created_by: data.created_by || null
      };

      const createdBrand = await createBrandDb(brandData);
      if (!createdBrand || !createdBrand.brand_id) {
        throw new Error('Failed to create brand');
      }

      const brandId = createdBrand.brand_id;

      for (const ec of data.error_code) {
        const errorCodePayload = {
          error_code: ec.error_code,
          error_code_name: ec.error_code_name || null,
          error_code_description: ec.error_code_description || null,
          error_code_color: ec.error_code_color || null,
          path_icon: ec.path_icon || null,
          is_active: ec.is_active,
          created_by: data.created_by || null
        };

        const errorId = await createErrorCodeDb(brandId, errorCodePayload);
        if (!errorId) {
          throw new Error('Failed to create error code');
        }

        // solutions
        if (Array.isArray(ec.solution)) {
          for (const s of ec.solution) {
            const solPayload = {
              solution_name: s.solution_name,
              type_solution: s.type_solution,
              text_solution: s.text_solution || null,
              path_solution: s.path_solution || null,
              is_active: s.is_active,
              created_by: data.created_by || null
            };
            await createSolutionDb(errorId, solPayload);
          }
        }

        // spareparts
        if (Array.isArray(ec.sparepart)) {
          for (const sp of ec.sparepart) {
            const spPayload = {
              sparepart_name: sp.sparepart_name,
              brand_sparepart_description: sp.brand_sparepart_description || null,
              path_foto: sp.path_foto || null,
              is_active: sp.is_active,
              created_by: data.created_by || null
            };
            await createSparePartDb(errorId, spPayload);
          }
        }
      }

      return await this.getBrandById(brandId);
    } catch (error) {
      if (error instanceof ErrorHandler) throw error;
      throw new ErrorHandler(500, error.message || 'Create brand failed');
    }
  }

  static async updateBrandWithFullData(id, data) {
    try {
      const existingBrand = await getBrandByIdDb(id);
      if (!existingBrand) throw new ErrorHandler(404, 'Brand not found');

      if (data.brand_name && data.brand_name !== existingBrand.brand_name) {
        const brandExists = await checkBrandNameExistsDb(data.brand_name, id);
        if (brandExists) throw new ErrorHandler(400, 'Brand name already exists');
      }

      const brandUpdatePayload = {
        brand_name: data.brand_name ?? existingBrand.brand_name,
        brand_type: data.brand_type ?? existingBrand.brand_type,
        brand_manufacture: data.brand_manufacture ?? existingBrand.brand_manufacture,
        brand_model: data.brand_model ?? existingBrand.brand_model,
        is_active: typeof data.is_active === 'boolean' ? data.is_active : existingBrand.is_active,
        updated_by: data.updated_by || null
      };
      await updateBrandDb(existingBrand.brand_name, brandUpdatePayload);

      if (!Array.isArray(data.error_code)) {
        return await this.getBrandById(id);
      }

      const existingErrorCodes = await getErrorCodesByBrandIdDb(id) || [];
      const incomingErrorCodes = data.error_code.map(ec => ec.error_code);

      for (const ec of data.error_code) {
        const existingEC = existingErrorCodes.find(e => e.error_code === ec.error_code);
        let errorId = null;

        if (existingEC) {
          const updatePayload = {
            error_code_name: ec.error_code_name ?? existingEC.error_code_name,
            error_code_description: ec.error_code_description ?? existingEC.error_code_description,
            error_code_color: ec.error_code_color ?? existingEC.error_code_color,
            path_icon: ec.path_icon ?? existingEC.path_icon,
            is_active: existingEC.is_active,
            updated_by: data.updated_by || null
          };
          await updateErrorCodeDb(existingEC.brand_id, existingEC.error_code, updatePayload);
          errorId = existingEC.error_code_id;
        } else {
          const createPayload = {
            error_code: ec.error_code,
            error_code_name: ec.error_code_name || null,
            error_code_description: ec.error_code_description || null,
            error_code_color: ec.error_code_color || null,
            path_icon: ec.path_icon || null,
            is_active: ec.is_active,
            created_by: data.updated_by || null
          };
          errorId = await createErrorCodeDb(id, createPayload);
        }

        if (!errorId) throw new Error(`Failed to create/update error code ${ec.error_code}`);

        const existingSolutions = await getSolutionsByErrorCodeIdDb(errorId) || [];
        const incomingSolutionNames = (ec.solution || []).map(s => s.solution_name);

        for (const s of (ec.solution || [])) {
          const existsSolution = existingSolutions.find(es => es.solution_name === s.solution_name);
          const solPayload = {
            solution_name: s.solution_name,
            type_solution: s.type_solution,
            text_solution: s.text_solution || null,
            path_solution: s.path_solution || null,
            is_active: s.is_active,
            updated_by: data.updated_by || null,
            created_by: data.updated_by || null
          };
          if (existsSolution) {
            await updateSolutionDb(existsSolution.brand_code_solution_id, solPayload);
          } else {
            await createSolutionDb(errorId, solPayload);
          }
        }

        for (const es of existingSolutions) {
          if (!incomingSolutionNames.includes(es.solution_name)) {
            await deleteSolutionDb(es.brand_code_solution_id, data.updated_by);
          }
        }

        const existingSpareparts = await getSparePartnsByErrorCodeIdDb(errorId) || [];
        const incomingSparepartNames = (ec.sparepart || []).map(sp => sp.sparepart_name);

        for (const sp of (ec.sparepart || [])) {
          const existsSP = existingSpareparts.find(e => e.sparepart_name === sp.sparepart_name);
          const spPayload = {
            sparepart_name: sp.sparepart_name,
            brand_sparepart_description: sp.brand_sparepart_description || null,
            path_foto: sp.path_foto || null,
            is_active: sp.is_active,
            updated_by: data.updated_by || null,
            created_by: data.updated_by || null
          };
          if (existsSP) {
            await updateSparePartDb(existsSP.brand_sparepart_id, spPayload);
          } else {
            await createSparePartDb(errorId, spPayload);
          }
        }

        for (const es of existingSpareparts) {
          if (!incomingSparepartNames.includes(es.sparepart_name)) {
            await deleteSparePartDb(es.brand_sparepart_id, data.updated_by);
          }
        }
      }

      for (const ec of existingErrorCodes) {
        if (!incomingErrorCodes.includes(ec.error_code)) {
          await deleteErrorCodeDb(id, ec.error_code, data.updated_by);
        }
      }

      return await this.getBrandById(id);
    } catch (error) {
      if (error instanceof ErrorHandler) throw error;
      throw new ErrorHandler(500, `Update failed: ${error.message || 'unknown error'}`);
    }
  }

  static async deleteBrand(id, userId) {
    try {
      const brandExist = await getBrandByIdDb(id);
      if (!brandExist) throw new ErrorHandler(404, 'Brand not found');
      const result = await deleteBrandDb(id, userId);
      return result;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message || 'Delete failed');
    }
  }
}

module.exports = BrandService;