import { defineStore } from 'pinia'
import api from '../axios'

export const useReglaAreaProcesoStore = defineStore('reglaAreaProceso', {
  state: () => ({
    areaProcesoId: null,
    proceso: null,
    reglas: [],
    areaProcesos: [],
    cargando: false,
    guardando: false,
    error: null,
    totalPreguntasAsignadas: 0,
    preguntasDisponibles: 0,
  }),

  getters: {
    totalPreguntasProceso: (state) => state.proceso?.cantidad_total_preguntas || 0,
    
    limiteAlcanzado: (state) => state.totalPreguntasAsignadas >= (state.proceso?.cantidad_total_preguntas || 0),
  },

  actions: {

    async setAreaProceso(id) {
      this.areaProcesoId = id
      await this.cargarReglas()
    },
async cargarAreaProcesos() {
  this.cargando = true
  try {

    const { data } = await api.get('/area-proceso/areasprocesos')



    this.areaProcesos = data.areaProcesos

  } catch (err) {
    console.error(err)
    this.error = err.response?.data?.message || 'Error al cargar áreas-proceso'
  } finally {
    this.cargando = false
  }
},


    async cargarReglas() {
      if (!this.areaProcesoId) return
      this.cargando = true
      this.error = null
      try {
        const { data } = await api.get(`/area-proceso/${this.areaProcesoId}/reglas`)
        this.proceso = data.proceso
        this.reglas = data.cursos
        this.totalPreguntasAsignadas = data.total_preguntas_asignadas || 0
        this.preguntasDisponibles = this.proceso.cantidad_total_preguntas - this.totalPreguntasAsignadas
      } catch (err) {
        console.error('Error al cargar reglas:', err)
        this.error = err.response?.data?.message || 'Error al cargar reglas'
      } finally {
        this.cargando = false
      }
    },



    async guardarRegla(regla) {
      if (!this.areaProcesoId) return
      this.guardando = true
      this.error = null
      try {
        const { data } = await api.post(`/area-proceso/${this.areaProcesoId}/reglas`, regla)
        
        const index = this.reglas.findIndex(r => r.curso_id === data.regla.curso_id)
        if (index >= 0) {
          this.reglas[index] = { ...this.reglas[index], ...data.regla }
        } else {
          this.reglas.push(data.regla)
        }
        this.reglas.sort((a, b) => (a.orden || 999) - (b.orden || 999))
        

        this.totalPreguntasAsignadas = data.total_preguntas_asignadas
        this.preguntasDisponibles = data.preguntas_disponibles
        
        return { success: true, data }
      } catch (err) {
        console.error('Error al guardar regla:', err)
        this.error = err.response?.data?.error || err.response?.data?.message || 'Error al guardar regla'
        return { 
          success: false, 
          error: this.error 
        }
      } finally {
        this.guardando = false
      }
    },


    async guardarReglasMultiple(reglas) {
      if (!this.areaProcesoId) return
      this.guardando = true
      this.error = null
      try {
        const { data } = await api.post(`/area-proceso/${this.areaProcesoId}/reglas/multiple`, {
          reglas: reglas
        })
        
        await this.cargarReglas()
        
        return { success: true, data }
      } catch (err) {
        console.error('Error al guardar reglas:', err)
        this.error = err.response?.data?.error || err.response?.data?.message || 'Error al guardar reglas'
        return { 
          success: false, 
          error: this.error 
        }
      } finally {
        this.guardando = false
      }
    },


    async editarRegla(reglaId, cambios) {
      this.guardando = true
      this.error = null
      try {
        const { data } = await api.put(`/reglas/${reglaId}`, cambios)
        
        const index = this.reglas.findIndex(r => r.regla_id === reglaId)
        if (index >= 0) {
          this.reglas[index] = { ...this.reglas[index], ...data.regla }
        }
        
        if (data.total_preguntas_asignadas !== undefined) {
          this.totalPreguntasAsignadas = data.total_preguntas_asignadas
          this.preguntasDisponibles = this.proceso.cantidad_total_preguntas - this.totalPreguntasAsignadas
        }

        this.reglas.sort((a, b) => (a.orden || 999) - (b.orden || 999))
        
        return { success: true, data }
      } catch (err) {
        console.error('Error al editar regla:', err)
        this.error = err.response?.data?.error || err.response?.data?.message || 'Error al editar regla'
        return { 
          success: false, 
          error: this.error 
        }
      } finally {
        this.guardando = false
      }
    },


    async eliminarRegla(reglaId) {
      this.guardando = true
      this.error = null
      try {
        const { data } = await api.delete(`/reglas/${reglaId}`)
        
        this.reglas = this.reglas.filter(r => r.regla_id !== reglaId)
        
        if (data.total_preguntas_asignadas !== undefined) {
          this.totalPreguntasAsignadas = data.total_preguntas_asignadas
          this.preguntasDisponibles = this.proceso.cantidad_total_preguntas - this.totalPreguntasAsignadas
        }
        
        return { success: true, data }
      } catch (err) {
        console.error('Error al eliminar regla:', err)
        this.error = err.response?.data?.message || 'Error al eliminar regla'
        return { 
          success: false, 
          error: this.error 
        }
      } finally {
        this.guardando = false
      }
    },


    async reordenarReglas(reglasOrdenadas) {
      reglasOrdenadas.forEach((regla, index) => {
        const reglaIndex = this.reglas.findIndex(r => r.curso_id === regla.curso_id)
        if (reglaIndex >= 0) {
          this.reglas[reglaIndex].orden = index + 1
        }
      })
      
      this.reglas.sort((a, b) => a.orden - b.orden)
      
      const reglasConId = this.reglas.filter(r => r.regla_id)
      
      if (reglasConId.length > 0) {

        for (const regla of reglasConId) {
          if (regla.regla_id) {
            await this.editarRegla(regla.regla_id, { orden: regla.orden })
          }
        }
      }
    },
    

    calcularPreguntasDisponibles(cursoId, cantidadActual = 0) {
      const otrasReglas = this.reglas.filter(r => r.curso_id !== cursoId)
      const totalOtras = otrasReglas.reduce((sum, r) => sum + (r.cantidad_preguntas || 0), 0)
      return Math.max(0, this.totalPreguntasProceso - totalOtras - cantidadActual)
    },
    
   
    reset() {
      this.areaProcesoId = null
      this.proceso = null
      this.reglas = []
      this.totalPreguntasAsignadas = 0
      this.preguntasDisponibles = 0
      this.error = null
    },
  }
})