import React, { useState } from 'react';
import {
  Box, Typography, TextField, Button, Paper, CircularProgress, Alert,
  FormControl,
  InputLabel,
  Select,
  MenuItem,
  FormHelperText
} from '@mui/material';
import DownloadIcon from '@mui/icons-material/Download';
import radioListaService from '../../services/Radios/radioListaService';
import type { GenerarListaRadioRequestDto } from '../../models/dtos/Radios/GenerarListaRadioRequestDto';
import { usePermissions } from '../../hooks/usePermissions';
import axios from 'axios'; // Para el manejo de errores de Axios

const GestionarListasRadioPage: React.FC = () => {
  const currentYear = new Date().getFullYear();
  const currentMonth = new Date().getMonth() + 1; // Meses son 0-indexados

  const [mes, setMes] = useState<string>(currentMonth.toString());
  const [anio, setAnio] = useState<string>(currentYear.toString());
  const [institucion, setInstitucion] = useState<"AADI" | "SADAIC">("AADI");
  const [radio, setRadio] = useState<"FM 99.1" | "FM 100.3">("FM 99.1");

  const [loading, setLoading] = useState(false);
  const [apiErrorMessage, setApiErrorMessage] = useState<string | null>(null);
  const [apiSuccessMessage, setApiSuccessMessage] = useState<string | null>(null);
  const [localErrors, setLocalErrors] = useState<{ [key: string]: string | null }>({});

  const { tienePermiso, isSuperAdmin } = usePermissions();
  // Usar el permiso general de la sección Radios (SS005) o uno específico
  const puedeGenerar = isSuperAdmin || tienePermiso("SS005");

  const validate = (): boolean => {
    const errors: { [key: string]: string | null } = {};
    const numMes = parseInt(mes, 10);
    const numAnio = parseInt(anio, 10);

    if (!mes.trim() || isNaN(numMes) || numMes < 1 || numMes > 12) {
      errors.mes = 'Mes debe ser un número entre 1 y 12.';
    }
    if (!anio.trim() || isNaN(numAnio) || numAnio < 2000 || numAnio > 2999) {
      errors.anio = 'Año debe ser válido (ej: 2024).';
    }
    if (!institucion) errors.institucion = 'Institución es obligatoria.'; // Aunque el estado tiene tipo, la validación es buena
    if (!radio) errors.radio = 'Radio es obligatoria.';

    setLocalErrors(errors);
    return Object.keys(errors).length === 0;
  };

  const handleGenerarLista = async () => {
    clearMessages();
    if (!validate()) return;

    setLoading(true);
    try {
      const params: GenerarListaRadioRequestDto = {
        mes: parseInt(mes, 10),
        anio: parseInt(anio, 10),
        institucion,
        radio,
      };

      const blob = await radioListaService.generarListaRadio(params);

      const url = window.URL.createObjectURL(blob);
      const link = document.createElement('a');
      link.href = url;

      // Construir el nombre de archivo como en VB.NET para el zip
      // Ejemplo AADI-FM99.1-FM-0524.xlsx.zip
      const mesTexto = params.mes.toString().padStart(2, '0');
      const anioCortoTexto = (params.anio % 100).toString().padStart(2, '0');
      let baseFileName = "";
      if (params.institucion === "AADI") {
        baseFileName = params.radio === "FM 99.1" ? `AADI-FM99.1-FM-${mesTexto}${anioCortoTexto}` : `AADI-FM100.3-FM-${mesTexto}${anioCortoTexto}`;
      } else { // SADAIC
        baseFileName = params.radio === "FM 99.1" ? `FM99.1-FM-${mesTexto}${anioCortoTexto}` : `FM100.3-FM-${mesTexto}${anioCortoTexto}`;
      }
      const defaultFileName = `${baseFileName}.zip`; // Nombre final del ZIP

      link.setAttribute('download', defaultFileName);
      document.body.appendChild(link);
      link.click();
      link.parentNode?.removeChild(link);
      window.URL.revokeObjectURL(url); // Liberar el objeto URL
      setApiSuccessMessage('Lista generada y descarga iniciada.');

    } catch (err: any) {
      console.error("Error al generar lista:", err);
      if (axios.isAxiosError(err) && err.response) {
        if (err.response.data instanceof Blob && err.response.data.type === "application/json") {
          // Intentar leer el error JSON del Blob
          const errorJson = await err.response.data.text();
          try {
            const parsedError = JSON.parse(errorJson);
            setApiErrorMessage(parsedError.message || 'Error al generar la lista.');
          } catch (parseError) {
            setApiErrorMessage('Error al generar la lista. Respuesta de error no válida.');
          }
        } else {
          setApiErrorMessage(err.response.data?.message || err.message || 'Error desconocido al generar la lista.');
        }
      } else {
        setApiErrorMessage('Error al generar la lista.');
      }
    } finally {
      setLoading(false);
    }
  };

  const clearMessages = () => {
    setApiErrorMessage(null);
    setApiSuccessMessage(null);
  };
  const handleInputChange = (fieldName: string) => {
    if (localErrors[fieldName]) setLocalErrors(prev => ({ ...prev, [fieldName]: null }));
    clearMessages();
  };


  if (!puedeGenerar) {
    return <Box sx={{ p: 2 }}><Alert severity="error">Acceso denegado.</Alert></Box>;
  }

  return (
    <Box sx={{ p: 1 }}>
      <Typography variant="h5" gutterBottom>Generar Listas de Radio</Typography>
      <Paper sx={{ p: 3, mb: 2 }}>
        <Typography variant="h6" gutterBottom>Criterios de Generación</Typography>
        <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2.5 }}> {/* Aumentado el gap */}
          <TextField
            label="Mes (1-12)"
            type="number"
            value={mes}
            onChange={(e) => { setMes(e.target.value); handleInputChange('mes'); }}
            error={!!localErrors.mes}
            helperText={localErrors.mes || ''}
            InputLabelProps={{ shrink: true }}
            inputProps={{ min: 1, max: 12 }}
            required
            fullWidth
          />
          <TextField
            label="Año (ej: 2024)"
            type="number"
            value={anio}
            onChange={(e) => { setAnio(e.target.value); handleInputChange('anio'); }}
            error={!!localErrors.anio}
            helperText={localErrors.anio || ''}
            InputLabelProps={{ shrink: true }}
            inputProps={{ min: 2000, max: 2099 }}
            required
            fullWidth
          />
          <FormControl fullWidth required error={!!localErrors.institucion}>
            <InputLabel id="institucion-select-label">Institución</InputLabel>
            <Select
              labelId="institucion-select-label"
              id="institucion-select"
              name="institucion"
              value={institucion}
              label="Institución"
              onChange={(e) => { setInstitucion(e.target.value as "AADI" | "SADAIC"); handleInputChange('institucion'); }}
            >
              <MenuItem value="AADI">AADI</MenuItem>
              <MenuItem value="SADAIC">SADAIC</MenuItem>
            </Select>
            {localErrors.institucion && <FormHelperText>{localErrors.institucion}</FormHelperText>}
          </FormControl>

          <FormControl fullWidth required error={!!localErrors.radio}>
            <InputLabel id="radio-select-label">Radio</InputLabel>
            <Select
              labelId="radio-select-label"
              id="radio-select"
              name="radio"
              value={radio}
              label="Radio"
              onChange={(e) => { setRadio(e.target.value as "FM 99.1" | "FM 100.3"); handleInputChange('radio'); }}
            >
              <MenuItem value="FM 99.1">FM 99.1</MenuItem>
              <MenuItem value="FM 100.3">FM 100.3</MenuItem>
            </Select>
            {localErrors.radio && <FormHelperText>{localErrors.radio}</FormHelperText>}
          </FormControl>

          <Button
            variant="contained"
            color="primary"
            startIcon={loading ? <CircularProgress size={20} color="inherit" /> : <DownloadIcon />}
            onClick={handleGenerarLista}
            disabled={loading}
            sx={{ mt: 1, alignSelf: 'flex-start' }} // Un pequeño margen superior
          >
            Generar y Descargar Lista
          </Button>
        </Box>
      </Paper>

      {loading && <Box sx={{ display: 'flex', justifyContent: 'center', my: 2 }}><CircularProgress /></Box>}
      {apiErrorMessage && <Alert severity="error" sx={{ my: 2 }}>{apiErrorMessage}</Alert>}
      {apiSuccessMessage && <Alert severity="success" sx={{ my: 2 }}>{apiSuccessMessage}</Alert>}

    </Box>
  );
};

export default GestionarListasRadioPage;