/* eslint-disable import/no-unresolved */
/* eslint-disable import/order */


import { sageService } from '@/service/sageService';
import { ComptesResponse, DeviseResponse, EncaissementResponse, ModeResponse, ReglementPostResponse, ReglementRequest, ReglementsIdResponse, reglementsResponse, TauxResponse, TresorerieResponse } from '@/types/reglementType';
import { createAsyncThunk } from '@reduxjs/toolkit';


/**
 * ✅ Thunk unifié pour charger toutes les données de règlement en parallèle
 */
export const loadAllReglementData = createAsyncThunk(
  'reglement/loadAll',
  async (_, { rejectWithValue }) => {
    try {
      // Lancer tous les appels en parallèle avec Promise.all
      const [reglementsRes, modesRes, devisesRes, tresoreriesRes, comptesRes, tauxRes] = await Promise.all([
        sageService.getReglement().catch(() => ({ success: false, data: {} })),
        sageService.getMode().catch(() => ({ success: false, data: { modes: [] } })),
        sageService.getDevises().catch(() => ({ success: false, data: { devises: [] } })),
        sageService.getTresorerie().catch(() => ({ success: false, data: { journaux: [] } })),
        sageService.getCompteGeneraux().catch(() => ({ success: false, data: { comptes: [] } })),
        sageService.getTaux().catch(() => ({ success: false, data: { taux: [] } })),
      ]);
      
      // Extraire les données de chaque réponse
      return {
        reglements: (reglementsRes as reglementsResponse)?.data || [],
        modes: (modesRes as ModeResponse)?.data?.modes || [],
        devises: (devisesRes as DeviseResponse)?.data?.devises || [],
        tresoreries: (tresoreriesRes as TresorerieResponse)?.data?.journaux || [],
        comptes: (comptesRes as ComptesResponse)?.data?.comptes || [],
        taux: (tauxRes as TauxResponse)?.data?.taux || [],
      };
    } catch (error: any) {
      return rejectWithValue(error.message || "Erreur lors du chargement des données de règlement");
    }
  }
);




/**
 * regler facture
 */
export const reglerFacture = createAsyncThunk(
  'reglement/reglerFacture',
  async (data: ReglementRequest): Promise<ReglementPostResponse> => {
    try {
      return await sageService.reglerFacture(data);
    } catch (err) {
      throw err;
    }
  }
);




/**
 * get reglement by id
 */
export const getReglementId = createAsyncThunk(
  'reglement/getReglementId',
  async (id: string): Promise<ReglementsIdResponse> => {
    try {
      return await sageService.getReglementId(id);
    } catch (err) {
      throw err;
    }
  }
);



/**
 * get reglement
 */
export const getReglement = createAsyncThunk(
  'reglement/getReglement',
  async (): Promise<reglementsResponse> => {
    try {
      return await sageService.getReglement();
    } catch (err) {
      throw err;
    }
  }
);



/**
 * get mode
 */
export const getMode = createAsyncThunk(
  'reglement/getMode',
  async (): Promise<ModeResponse> => {
    try {
      return await sageService.getMode();
    } catch (err) {
      throw err;
    }
  }
);


/**
 * get devises
 */
export const getDevises = createAsyncThunk(
  'reglement/getDevises',
  async (): Promise<DeviseResponse> => {
    try {
      return await sageService.getDevises();
    } catch (err) {
      throw err;
    }
  }
);

/**
 * get trésorerie
 */
export const getTresorerie = createAsyncThunk(
  'reglement/getTresorerie',
  async (): Promise<TresorerieResponse> => {
    try {
      return await sageService.getTresorerie();
    } catch (err) {
      throw err;
    }
  }
);

/**
 * get comptes généraux
 */
export const getCompteGeneraux = createAsyncThunk(
  'reglement/getCompteGeneraux',
  async (): Promise<ComptesResponse> => {
    try {
      return await sageService.getCompteGeneraux();
    } catch (err) {
      throw err;
    }
  }
);

/**
 * get taux
 */
export const getTaux = createAsyncThunk(
  'reglement/getTaux',
  async (): Promise<TauxResponse> => {
    try {
      return await sageService.getTaux();
    } catch (err) {
      throw err;
    }
  }
);

/**
 * get encaissement
 */
export const getEncaissement = createAsyncThunk(
  'reglement/getEncaissement',
  async (): Promise<EncaissementResponse> => {
    try {
      return await sageService.getEncaissement();
    } catch (err) {
      throw err;
    }
  }
);
