import apiClient from "@/infrastructure/apiClient";
import apiPath from "@/infrastructure/apiPath";

const incomeCategoryService = {
  /**
   * Tìm kiếm danh mục doanh thu với phân trang
   * @param {Object} searchModel - Model tìm kiếm
   * @param {Object} searchModel.Pagination - Thông tin phân trang
   * @param {Object} searchModel.Search - Bộ lọc tìm kiếm
   * @param {Object} searchModel.Sort - Thông tin sắp xếp
   * @returns {Promise<Object>} Kết quả tìm kiếm
   */
  async search(searchModel) {
    try {
      const params = JSON.parse(JSON.stringify(searchModel));
      const response = await apiClient.post(
        apiPath.incomeCategory.search,
        params
      );
      const data = response.data;

      // Chuyển đổi format response để tương thích với giao diện hiện tại
      return {
        Items: data.Items || [],
        TotalRecord: data.TotalRecord || 0,
        NumberOfPages: data.NumberOfPages || 0,
        TotalCount: data.TotalRecord || 0,
        Pagination: data.Pagination || {},
      };
    } catch (error) {
      console.error("Error searching income categories:", error);
      return {
        Items: [],
        TotalRecord: 0,
        NumberOfPages: 0,
        TotalCount: 0,
        Pagination: {},
      };
    }
  },

  /**
   * Lấy thông tin danh mục doanh thu theo ID
   * @param {number} id - ID của danh mục doanh thu
   * @returns {Promise<Object|null>} Thông tin danh mục doanh thu
   */
  async getById(id) {
    try {
      const response = await apiClient.get(
        `${apiPath.incomeCategory.getById}/${id}`
      );
      return response.data;
    } catch (error) {
      console.error("Error getting income category by ID:", error);
      return null;
    }
  },

  /**
   * Tạo mới hoặc cập nhật danh mục doanh thu
   * @param {Object} categoryModel - Dữ liệu danh mục doanh thu
   * @returns {Promise<Object>} Kết quả tạo mới hoặc cập nhật
   */
  async createOrUpdate(categoryModel) {
    try {
      const params = JSON.parse(JSON.stringify(categoryModel));
      const response = await apiClient.post(
        apiPath.incomeCategory.createOrUpdate,
        params
      );
      return response.data;
    } catch (error) {
      console.error("Error creating or updating income category:", error);
      return {
        Result: "Error",
        Message: "Có lỗi xảy ra khi lưu danh mục doanh thu",
      };
    }
  },

  /**
   * Xóa danh mục doanh thu
   * @param {number} id - ID của danh mục doanh thu
   * @returns {Promise<Object>} Kết quả xóa
   */
  async delete(id) {
    try {
      const response = await apiClient.delete(
        `${apiPath.incomeCategory.delete}/${id}`
      );
      return response.data;
    } catch (error) {
      console.error("Error deleting income category:", error);
      return {
        Result: "Error",
        Message: "Có lỗi xảy ra khi xóa danh mục doanh thu",
      };
    }
  },

  /**
   * Lấy tất cả danh mục doanh thu (cho dropdown)
   * @returns {Promise<Array>} Danh sách danh mục doanh thu
   */
  async getAll() {
    try {
      const response = await apiClient.get(apiPath.incomeCategory.getAll);
      return response.data || [];
    } catch (error) {
      console.error("Error getting all income categories:", error);
      return [];
    }
  },

  /**
   * Kiểm tra tên danh mục có trùng lặp không
   * @param {string} name - Tên cần kiểm tra
   * @param {number} excludeId - ID loại trừ (khi update)
   * @returns {Promise<boolean>} True nếu tên đã tồn tại
   */
  async checkNameExists(name, excludeId = null) {
    try {
      let url = `${
        apiPath.incomeCategory.checkNameExists
      }?name=${encodeURIComponent(name)}`;
      if (excludeId) {
        url += `&excludeId=${excludeId}`;
      }
      const response = await apiClient.get(url);
      return response.data?.exists || false;
    } catch (error) {
      console.error("Error checking name exists:", error);
      return false;
    }
  },

  /**
   * Tạo model tìm kiếm mặc định
   * @returns {Object} Model tìm kiếm mặc định
   */
  createDefaultSearchModel() {
    return {
      Pagination: {
        From: 0,
        PageIndex: 1,
        PageSize: 10,
        Total: 0,
        TotalPages: 0,
        TotalItemCount: 0,
        Number: 1,
        NumberOfPages: 0,
      },
      Search: {
        PredicateObject: {
          Name: "",
          Description: "",
          ParentId: null,
          DisplayMode: "List", // Default to List mode
        },
      },
      Sort: {
        Predicate: "DisplayOrder",
        Reverse: false,
      },
      IsExport: false,
    };
  },

  /**
   * Lấy danh sách danh mục theo cây phân cấp
   * @returns {Promise<Array>} Danh sách danh mục theo cây phân cấp
   */
  async getHierarchy() {
    try {
      const response = await apiClient.get(apiPath.incomeCategory.hierarchy);
      return response.data || [];
    } catch (error) {
      console.error("Error getting income category hierarchy:", error);
      return [];
    }
  },

  /**
   * Lấy danh sách danh mục gốc
   * @returns {Promise<Array>} Danh sách danh mục gốc
   */
  async getRootCategories() {
    try {
      const response = await apiClient.get(
        apiPath.incomeCategory.rootCategories
      );
      return response.data || [];
    } catch (error) {
      console.error("Error getting root categories:", error);
      return [];
    }
  },

  /**
   * Lấy danh sách danh mục con
   * @param {number} parentId - ID của danh mục cha
   * @returns {Promise<Array>} Danh sách danh mục con
   */
  async getChildren(parentId) {
    try {
      const response = await apiClient.get(
        `${apiPath.incomeCategory.children}/${parentId}`
      );
      return response.data || [];
    } catch (error) {
      console.error("Error getting children categories:", error);
      return [];
    }
  },

  /**
   * Kiểm tra có thể xóa danh mục không
   * @param {number} id - ID của danh mục
   * @returns {Promise<boolean>} True nếu có thể xóa
   */
  async canDelete(id) {
    try {
      const response = await apiClient.get(
        `${apiPath.incomeCategory.canDelete}/${id}`
      );
      return response.data?.canDelete || false;
    } catch (error) {
      console.error("Error checking if can delete category:", error);
      return false;
    }
  },

  /**
   * Tạo model danh mục doanh thu mặc định
   * @returns {Object} Model danh mục doanh thu mặc định
   */
  createDefaultCategoryModel() {
    return {
      Id: 0,
      Name: "",
      AccountCode: "",
      Description: "",
      DisplayOrder: 1,
      ParentId: null,
      ApprovedBy: null,
    };
  },
};

export default incomeCategoryService;
