import axios from 'axios';

// 检查模板类型
export interface InspectionTemplate {
  id: number;
  name: string;
  description?: string;
  items: InspectionItem[];
  createdAt: string;
  updatedAt: string;
}

export interface InspectionItem {
  id: number;
  name: string;
  description?: string;
  required: boolean;
}

// 检查任务类型
export interface InspectionTask {
  id: number;
  templateId: number;
  name: string;
  taskNo: string;
  description?: string;
  status: 'pending' | 'in_progress' | 'completed' | 'failed';
  startTime?: string;
  endTime?: string;
  createdAt: string;
  updatedAt: string;
  schedule_type?: 'manual' | 'scheduled' | 'yearly';
  cronExpression?: string;
  intervalDays?: number;
  deviceTypes?: string[];
  run_immediately?: boolean;
  progress?: number;
  checked_count?: number;
  issues_found?: number;
}

// 检查结果类型
export interface InspectionResult {
  id: number;
  taskId: number;
  itemId: number;
  status: 'passed' | 'failed' | 'skipped';
  notes?: string;
  createdAt: string;
}

// 报告接收者类型
export interface ReportReceiver {
  id: number;
  name: string;
  email: string;
  createdAt: string;
}

// API响应类型
export interface ListResponse<T> {
  data: T[];
  total: number;
  page: number;
  pageSize: number;
}

export interface SingleResponse<T> {
  data: T;
  message?: string;
}

export interface CreateResponse<T> {
  data: T;
  message: string;
}

export interface UpdateResponse<T> {
  data: T;
  message: string;
}

export interface DeleteResponse {
  message: string;
}

// 检查API接口定义
export const InspectionsAPI = {
  // 模板相关API
  getTemplates: async (params?: {
    page?: number;
    limit?: number;
    name?: string;
  }): Promise<ListResponse<InspectionTemplate>> => {
    try {
      const response = await axios.get('/inspections/templates', { params });
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  createTemplate: async (data: Omit<InspectionTemplate, 'id' | 'createdAt' | 'updatedAt'>): Promise<CreateResponse<InspectionTemplate>> => {
    try {
      const response = await axios.post('/inspections/templates', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  updateTemplate: async (id: number, data: Partial<InspectionTemplate>): Promise<UpdateResponse<InspectionTemplate>> => {
    try {
      const response = await axios.put(`/inspections/templates/${id}`, data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  createAutoInspectionTask: async (data: {
    taskNo: string;
    cronExpression?: string;
    intervalDays?: number;
    deviceTypes?: string[];
    reportReceivers?: string[];
  }): Promise<CreateResponse<InspectionTask>> => {
    try {
      const response = await axios.post('/inspections/auto-tasks', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  deleteTemplate: async (id: number): Promise<DeleteResponse> => {
    try {
      const response = await axios.delete(`/inspections/templates/${id}`);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  // 任务相关API
  getTasks: async (params?: {
    page?: number;
    limit?: number;
    status?: string;
    templateId?: number;
  }): Promise<ListResponse<InspectionTask>> => {
    try {
      const response = await axios.get('/inspections/tasks', { params });
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  createTask: async (data: Omit<InspectionTask, 'id' | 'status' | 'createdAt' | 'updatedAt'>): Promise<CreateResponse<InspectionTask>> => {
    try {
      const response = await axios.post('/inspections/tasks', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  createAutoTask: async (data: {
    name: string;
    intervalDays: number;
    deviceTypes?: string[];
  }): Promise<CreateResponse<InspectionTask>> => {
    try {
      const response = await axios.post('/inspections/tasks/auto', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  runManualTask: async (data: {
    deviceTypes?: string[];
  }): Promise<UpdateResponse<InspectionTask>> => {
    try {
      const response = await axios.post('/inspections/tasks/manual', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  runTask: async (id: number): Promise<UpdateResponse<InspectionTask>> => {
    try {
      const response = await axios.post(`/inspections/tasks/${id}/run`);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  // 结果相关API
  getResults: async (params?: {
    page?: number;
    limit?: number;
    taskId?: number;
    status?: string;
  }): Promise<ListResponse<InspectionResult>> => {
    try {
      const response = await axios.get('/inspections/results', { params });
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  exportReport: async (id: number): Promise<Blob> => {
    try {
      const response = await axios.get(`/inspections/results/${id}/export`, {
        responseType: 'blob'
      });
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  // 接收者相关API
  getReceivers: async (params?: {
    page?: number;
    limit?: number;
  }): Promise<ListResponse<ReportReceiver>> => {
    try {
      const response = await axios.get('/inspections/receivers', { params });
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  addReceiver: async (data: Omit<ReportReceiver, 'id' | 'createdAt'>): Promise<CreateResponse<ReportReceiver>> => {
    try {
      const response = await axios.post('/inspections/receivers', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  removeReceiver: async (id: number): Promise<DeleteResponse> => {
    try {
      const response = await axios.delete(`/inspections/receivers/${id}`);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  // 新年巡检专用API
  createNewYearTask: async (data: {
    id: string;
    time: string;
    deviceType: string;
    status: string;
    issuesFound: number;
    receiverId: string;
  }): Promise<CreateResponse<InspectionTask>> => {
    try {
      const response = await axios.post('/inspections/tasks/new-year', data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  updateProgress: async (id: number, data: {
    progress: number;
    checkedCount: number;
    issuesFound: number;
  }): Promise<UpdateResponse<InspectionTask>> => {
    try {
      const response = await axios.put(`/inspections/tasks/${id}/progress`, data);
      return response.data;
    } catch (error) {
      throw error;
    }
  },

  completeInspection: async (id: number, results: {
    itemId: number;
    status: 'passed' | 'failed' | 'skipped';
    notes?: string;
  }[]): Promise<UpdateResponse<InspectionTask>> => {
    try {
      const response = await axios.post(`/inspections/tasks/${id}/complete`, { results });
      return response.data;
    } catch (error) {
      throw error;
    }
  }
};