import api from '@/services/api';

/**
 * Busca os dados iniciais para montagem do ambiente GR.
 * @returns {Promise<Object>}
 */
export const getGrEnvironment = async () => {
  const response = await api.get('/mounting_gr');
  return response.data;
};

/**
 * Busca motoristas com base em filtros de frota.
 * @param {Object} params { grupo, base, filtro }
 * @returns {Promise<Object>}
 */
export const getDriversByFilter = async (params) => {
  const response = await api.post('/base/filtro', params);
  return response.data;
};

/**
 * Atualiza o status global de um motorista no Kanban.
 * @param {Object} data { global_status, iddrivers }
 * @returns {Promise<Object>}
 */
export const updateDriverStatus = async (data) => {
  const response = await api.request({
    url: '/cadastro/drivers/edit/status',
    method: 'UPDATE',
    data: data
  });
  return response.data;
};

/**
 * Busca contratos de motoristas por base.
 * @param {string} base 
 * @returns {Promise<Object>}
 */
export const getDriverContracts = async (base) => {
  const response = await api.get(`/contrato/drivers/filtro?base=${base}`);
  return response.data;
};

/**
 * Busca todos os cadastros de motoristas.
 * @param {string} modalidade - Opcional: 'agregado_rentals', 'frota_fixa', ou null para todos
 * @returns {Promise<Object>}
 */
export const getAllDriverRegistrations = async (modalidade = null) => {
  const url = modalidade 
    ? `/cadastro/drivers/apresentar/modalidade/${modalidade}`
    : '/cadastro/drivers/apresentar';
  const response = await api.get(url);
  return response.data;
};

/**
 * Busca cadastros arquivados.
 * GET /cadastro/drivers/arquivados
 * @returns {Promise<Object>}
 */
export const getArchivedRegistrations = async () => {
  const response = await api.get('/cadastro/drivers/arquivados');
  return response.data;
};

/**
 * Atualiza os dados cadastrais de um motorista.
 * @param {Object} data Objeto com os campos do formulário
 * @returns {Promise<Object>}
 */
export const updateDriverRegistration = async (data) => {
  const isFormData = data instanceof FormData;
  const response = await api.put('/cadastro/drivers/edit', data, {
    headers: isFormData ? { 'Content-Type': 'multipart/form-data' } : undefined
  });
  return response.data;
};

/**
 * Busca todos os contratos de motoristas.
 * @param {string} modalidade - Opcional: 'agregado', 'frota-fixa', ou null para todos
 * @returns {Promise<Object>}
 */
export const getActiveContracts = async (modalidade = null) => {
  const url = modalidade 
    ? `/contrato/drivers/apresentar?modalidade=${modalidade}`
    : '/contrato/drivers/apresentar';
  const response = await api.get(url);
  return response.data;
};

/**
 * Busca contratos arquivados.
 * GET /contrato/drivers/arquivados
 * @returns {Promise<Object>}
 */
export const getArchivedContracts = async () => {
  const response = await api.get('/contrato/drivers/arquivados');
  return response.data;
};

/**
 * Atualiza o status global de um contrato.
 * @param {Object} data { global_status, iddrivers }
 * @returns {Promise<Object>}
 */
export const updateContractGlobalStatus = async (data) => {
  const response = await api.request({
    url: '/contrato/drivers/edit/status_global',
    method: 'UPDATE',
    data: data
  });
  return response.data;
};

/**
 * Atualiza o status de assinatura de um contrato.
 * @param {Object} data { status_assinatura, iddrivers }
 * @returns {Promise<Object>}
 */
export const updateContractSignatureStatus = async (data) => {
  const response = await api.put('/contrato/drivers/edit/status_assinatura', data);
  return response.data;
};

/**
 * Busca a lista de usuários configurados no GR.
 * @returns {Promise<Object>}
 */
export const getUserList = async () => {
  const response = await api.get('/usuarios_gr');
  return response.data;
};

/**
 * Cria ou edita um usuário no GR.
 * @param {Object} data 
 * @returns {Promise<Object>}
 */
export const saveUser = async (data) => {
  const response = await api.post('/user_gr/edit', data);
  return response.data;
};

/**
 * Deleta um usuário.
 * @param {number} userId 
 * @returns {Promise<Object>}
 */
export const deleteUser = async (userId) => {
  const response = await api.delete('/user_gr/delete', { data: { idusuarios_pralog: userId } });
  return response.data;
};
/**
 * Cria um novo contrato.
 * @param {Object} data 
 * @returns {Promise<Object>}
 */
export const createContract = async (data) => {
  const response = await api.post('/contrato/drivers', data);
  return response.data;
};

/**
 * Atualiza um contrato existente.
 * O backend usa idcontrato_drivers como identificador do contrato.
 * @param {Object} data Deve incluir idcontrato_drivers ao editar
 * @returns {Promise<Object>}
 */
export const updateContract = async (data) => {
  const response = await api.put('/contrato/drivers/edit', data);
  return response.data;
};

/**
 * Arquiva um contrato existente.
 * Endpoint: PUT /contrato/arquivar/<int:idcontrato_drivers>
 * @param {number} idcontrato_drivers ID do contrato
 * @returns {Promise<Object>}
 */
export const archiveContract = async (idcontrato_drivers) => {
  if (!idcontrato_drivers) {
    throw new Error('ID do contrato (idcontrato_drivers) não informado para arquivamento.');
  }
  const response = await api.put(`/contrato/arquivar/${idcontrato_drivers}`);
  return response.data;
};

/**
 * Cria um novo usuário GR.
 * @param {Object} data 
 * @returns {Promise<Object>}
 */
export const createUser = async (data) => {
  const response = await api.post('/usuarios_gr/create', data);
  return response.data;
};

/**
 * Atualiza um usuário GR existente.
 * @param {Object} data 
 * @returns {Promise<Object>}
 */
export const updateUser = async (data) => {
  // Note: User requested /contrato/drivers/edit for editing users as well
  const response = await api.post('/user_gr/edit', data);
  return response.data;
};

/**
 * Busca a lista de grupos disponíveis no GR.
 * GET /grup_gr
 * @returns {Promise<Object>}
 */
export const getGrGroups = async () => {
  const response = await api.get('/grup_gr');
  return response.data;
};

/**
 * Arquiva um cadastro de motorista.
 * Endpoint backend: /cadatro/arquivar/<int:iddrivers>
 * (rota com grafia conforme backend)
 * @param {number} iddrivers 
 * @returns {Promise<Object>}
 */
export const archiveDriverRegistration = async (iddrivers) => {
  if (!iddrivers) {
    throw new Error('ID do cadastro não informado para arquivamento.');
  }
  const response = await api.put(`/cadatro/arquivar/${iddrivers}`);
  return response.data;
};

/**
 * Realiza o cadastro interno de um motorista (Novo Cadastro via Dashboard).
 * Endpoint: /cadastro/drivers/interno
 * @param {FormData} data FormData contendo imagens e dados_json
 * @returns {Promise<Object>}
 */
export const submitInternalDriverRegistration = async (data) => {
    const response = await api.post('/cadastro/drivers/interno', data, {
          headers: {
              'Content-Type': 'multipart/form-data'
          }
      });
      return response.data;
};

/**
 * Atualiza o status dos documentos do motorista (Motorista e Carro).
 * @param {Object} data { iddrivers, status_doc_motorista, status_doc_carro }
 * @returns {Promise<Object>}
 */
export const updateDriverDocStatus = async (data) => {
  const response = await api.request({
    url: '/cadastro/drivers/edit/status_motorista_carro',
    method: 'UPDATE',
    data: data
  });
  return response.data;
};

/**
 * Salva as credenciais de e-mail para processamento de XML.
 * @param {string} email 
 * @param {string} senha 
 * @returns {Promise<Object>}
 */
export const saveEmailCredentials = async (email, senha) => {
  const response = await api.post('/email_xml/credenciais', { email, senha });
  return response.data;
};

/**
 * Inicia o processamento de e-mails para extração de XML.
 * @param {Object} data { desde_data, assunto_filtro, salvar_xmls }
 * @returns {Promise<Object>}
 */
export const processEmails = async (data) => {
  const response = await api.post('/email_xml/processar', data);
  return response.data;
};

/**
 * Valida um arquivo XML enviado.
 * @param {File} file 
 * @returns {Promise<Object>}
 */
export const validateXML = async (file) => {
  const formData = new FormData();
  formData.append('file', file);
  const response = await api.post('/email_xml/validar', formData, {
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  });
  return response.data;
};


/**
 * Altera a senha do próprio usuário (utilizado por Despachante e Documentação).
 * Endpoint: /user_gr/senha
 * @param {Object} data { idusuarios_pralog, nome_completo, password }
 * @returns {Promise<Object>}
 */
export const changeUserPassword = async (data) => {
  const response = await api.post('/user_gr/senha', data);
  return response.data;
};

/**
 * Redefine a senha do usuário através de um token externo.
 * Endpoint: /ambiente_python/reset_password
 * @param {Object} data { token, senha }
 * @returns {Promise<Object>}
 */
export const resetPasswordExternal = async (data) => {
  const response = await api.post('/ambiente_python/reset_password', data);
  return response.data;
};

/**
 * Solicita a redefinição de senha enviando um e-mail.
 * Endpoint: /forgot_password
 * @param {Object} data { email }
 * @returns {Promise<Object>}
 */
export const requestPasswordReset = async (data) => {
  const response = await api.post('/forgot_password', data);
  return response.data;
};

/**
 * Busca a lista de bases cadastradas.
 * GET /bases/apresentar
 * @returns {Promise<Object>}
 */
export const getBases = async () => {
  const response = await api.get('/bases/apresentar');
  return response.data;
};

/**
 * Cria uma nova base.
 * POST /bases
 * Payload: { base: baseName }
 * @param {Object} data { base }
 * @returns {Promise<Object>}
 */
export const saveBase = async (data) => {
  const response = await api.post('/bases', data);
  return response.data;
};

/**
 * Atualiza uma base existente.
 * PUT /bases/:id
 * @param {Object} data { id, base }
 * @returns {Promise<Object>}
 */
export const updateBase = async (data) => {
  const payload = {
    idbase: data.idbase,
    base: data.base
  };
  const response = await api.put('/bases/editar', payload);
  return response.data;
};

/**
 * Deleta uma base.
 * DELETE /bases/:id
 * @param {number} id
 * @returns {Promise<Object>}
 */
export const deleteBase = async (id) => {
  const response = await api.delete('/bases/excluir', { data: { idbase: id } });
  return response.data;
};

/**
 * Busca a lista de responsáveis de base.
 * GET /responsavel_bases
 * @returns {Promise<Object>}
 */
export const getBaseResponsibles = async () => {
  const response = await api.get('/responsavel_bases');
  return response.data;
};

/**
 * Cria um novo responsável de base.
 * POST /responsavel_bases
 * Payload: { responsavel_base: name }
 * @param {Object} data { responsavel_base }
 * @returns {Promise<Object>}
 */
export const saveBaseResponsible = async (data) => {
  const response = await api.post('/responsavel_bases', data);
  return response.data;
};

/**
 * Atualiza um responsável existente.
 * PUT /responsavel_bases/:id
 * Payload: { novo_nome: name }
 * @param {Object} data { id, responsavel }
 * @returns {Promise<Object>}
 */
export const updateBaseResponsible = async (data) => {
  const payload = { 
    id_responsavel_base: data.id_responsavel_base,
    responsavel_base: data.responsavel_base 
  };
  const response = await api.put('/responsavel_bases/editar', payload);
  return response.data;
};

/**
 * Deleta um responsável de base.
 * DELETE /responsavel_bases/:id
 * @param {number} id
 * @returns {Promise<Object>}
 */
export const deleteBaseResponsible = async (id) => {
  const response = await api.delete('/responsavel_bases/excluir', { data: { id_responsavel_base: id } });
  return response.data;
};

/**
 * Desarquiva um cadastro de motorista.
 * Endpoint: PUT /cadatro/desarquivar/<int:iddrivers>
 * @param {number} iddrivers 
 * @returns {Promise<Object>}
 */
export const unarchiveDriverRegistration = async (iddrivers) => {
  if (!iddrivers) {
    throw new Error('ID do cadastro não informado para desarquivamento.');
  }
  const response = await api.put(`/cadatro/desarquivar/${iddrivers}`);
  return response.data;
};

/**
 * Desarquiva um contrato de motorista.
 * Endpoint: PUT /contrato/desarquivar/<int:idcontrato_drivers>
 * @param {number} idcontrato_drivers 
 * @returns {Promise<Object>}
 */
export const unarchiveContract = async (id) => {
  if (!id) {
    throw new Error('ID do contrato não informado para desarquivamento.');
  }
  const response = await api.put(`/contrato/desarquivar/${id}`);
  return response.data;
};
