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

const expenseCategoryService = {
  /**
   * Tìm kiếm danh mục chi phí 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.expenseCategory.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 expense categories:", error);
      return {
        Items: [],
        TotalRecord: 0,
        NumberOfPages: 0,
        TotalCount: 0,
        Pagination: {},
      };
    }
  },

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

  /**
   * Tạo mới hoặc cập nhật danh mục chi phí
   * @param {Object} categoryModel - Dữ liệu danh mục chi phí
   * @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.expenseCategory.createOrUpdate,
        params
      );
      return response.data;
    } catch (error) {
      console.error("Error creating or updating expense category:", error);
      return {
        Result: "Error",
        Message: "Có lỗi xảy ra khi lưu danh mục chi phí",
      };
    }
  },

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

  /**
   * Lấy tất cả danh mục chi phí (cho dropdown)
   * @returns {Promise<Array>} Danh sách danh mục chi phí
   */
  async getAll() {
    try {
      const response = await apiClient.get(apiPath.expenseCategory.getAll);
      return response.data || [];
    } catch (error) {
      console.error("Error getting all expense 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.expenseCategory.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: {
          Keyword: "",
          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.expenseCategory.hierarchy);
      return response.data || [];
    } catch (error) {
      console.error("Error getting expense 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.expenseCategory.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.expenseCategory.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.expenseCategory.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 chi phí mặc định
   * @returns {Object} Model danh mục chi phí mặc định
   */
  createDefaultCategoryModel() {
    return {
      Id: 0,
      Name: "",
      AccountCode: "",
      Description: "",
      DisplayOrder: 1,
      ParentId: null,
      ApprovedBy: null,
    };
  },
};

export default expenseCategoryService;
