import {
    AccountCircle,
    AlternateEmail,
    CheckCircle,
    Email,
    Lock,
    Person,
    Save,
    Visibility,
    VisibilityOff,
} from "@mui/icons-material";
import {
    Avatar,
    Box,
    Button,
    Chip,
    CircularProgress,
    Divider,
    IconButton,
    InputAdornment,
    Paper,
    TextField,
    Typography,
} from "@mui/material";
import { useMutation } from "@tanstack/react-query";
import { useEffect, useState } from "react";
import { Controller, useForm } from "react-hook-form";
import { toast } from "sonner";
import styled from "styled-components";
import { updateUsuario } from "../api/usuarios.service";
import { useAuthStore } from "../store/AuthStore";
import {
  TOUR_REGISTRY,
  isTourCompleted,
  resetAllTours,
  resetTour,
} from "../tours/registry";

export const MiPerfil = () => {
  const { user } = useAuthStore();
  const [showPassword, setShowPassword] = useState(false);
  const [showConfirmPassword, setShowConfirmPassword] = useState(false);

  const {
    control,
    handleSubmit,
    watch,
    reset,
    formState: { errors, isDirty },
  } = useForm({
    defaultValues: {
      nombres: user?.nombres || "",
      apellidos: user?.apellidos || "",
      username: user?.username || "",
      email: user?.email || "",
      password: "",
      confirmPassword: "",
    },
  });

  // Mutation para actualizar perfil
  const { mutate, isPending } = useMutation({
    mutationFn: (data) => updateUsuario(user?.id, data),
    onSuccess: (response) => {
      toast.success("Perfil actualizado correctamente");
      // Actualizar usuario en localStorage
      if (response?.data) {
        const updatedUser = { ...user, ...response.data };
        localStorage.setItem("user", JSON.stringify(updatedUser));
      }
      // Limpiar campos de contraseña
      reset((prev) => ({
        ...prev,
        password: "",
        confirmPassword: "",
      }));
    },
    onError: (error) => {
      toast.error(
        error.response?.data?.message || "Error al actualizar perfil",
      );
    },
  });

  // Cargar datos del usuario cuando estén disponibles
  useEffect(() => {
    if (user) {
      reset({
        nombres: user.nombres || "",
        apellidos: user.apellidos || "",
        username: user.username || "",
        email: user.email || "",
        password: "",
        confirmPassword: "",
      });
    }
  }, [user, reset]);

  const password = watch("password");

  const onSubmit = (data) => {
    const payload = {
      nombres: data.nombres,
      apellidos: data.apellidos,
      email: data.email,
    };

    // Solo incluir password si se ingresó una nueva
    if (data.password && data.password.trim() !== "") {
      payload.password = data.password;
    }

    mutate(payload);
  };

  // Obtener iniciales para el avatar
  const getInitials = (nombres, apellidos) => {
    const first = nombres?.charAt(0) || "";
    const last = apellidos?.charAt(0) || "";
    return (first + last).toUpperCase() || "U";
  };

  const fullName =
    [user?.nombres, user?.apellidos].filter(Boolean).join(" ") || "Usuario";

  return (
    <Container>
      <Box sx={{ maxWidth: 600, mx: "auto", py: 4 }}>
        {/* Header */}
        <Paper sx={{ p: 3, mb: 3 }}>
          <Box
            sx={{
              display: "flex",
              alignItems: "center",
              gap: 1.5,
              mb: 1,
            }}
          >
            <AccountCircle color="primary" />
            <Typography variant="h5" fontWeight={600}>
              Mi Perfil
            </Typography>
          </Box>
          <Typography variant="body2" color="text.secondary">
            Administra tu información personal y seguridad
          </Typography>
        </Paper>

        {/* Profile Card */}
        <Paper sx={{ p: 3, mb: 3 }}>
          <Box
            sx={{
              display: "flex",
              flexDirection: { xs: "column", sm: "row" },
              alignItems: "center",
              gap: 3,
              p: 3,
              bgcolor: "action.hover",
              borderRadius: 2,
              border: "1px solid",
              borderColor: "divider",
            }}
          >
            <Avatar
              sx={{
                width: 100,
                height: 100,
                bgcolor: "primary.main",
                fontSize: "2rem",
                fontWeight: 600,
              }}
            >
              {getInitials(user?.nombres, user?.apellidos)}
            </Avatar>
            <Box sx={{ textAlign: { xs: "center", sm: "left" }, flex: 1 }}>
              <Typography variant="h5" fontWeight={600}>
                {fullName}
              </Typography>
              <Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
                @{user?.username || "usuario"}
              </Typography>
              <Box
                sx={{
                  display: "flex",
                  gap: 1,
                  flexWrap: "wrap",
                  justifyContent: { xs: "center", sm: "flex-start" },
                }}
              >
                <Chip
                  icon={<CheckCircle />}
                  label={user?.estado || "Activo"}
                  color={user?.active ? "success" : "default"}
                  size="small"
                />
                {user?.verificado && (
                  <Chip
                    label="Verificado"
                    color="primary"
                    size="small"
                    variant="outlined"
                  />
                )}
              </Box>
            </Box>
          </Box>
        </Paper>

        {/* Form */}
        <Paper sx={{ p: 3 }}>
          <Typography variant="h6" sx={{ mb: 2 }}>
            Información Personal
          </Typography>
          <Divider sx={{ mb: 3 }} />

          <Box
            component="form"
            onSubmit={handleSubmit(onSubmit)}
            sx={{ display: "flex", flexDirection: "column", gap: 2.5 }}
          >
            <Box
              sx={{
                display: "flex",
                gap: 2,
                flexDirection: { xs: "column", sm: "row" },
              }}
            >
              <Controller
                name="nombres"
                control={control}
                rules={{ required: "El nombre es requerido" }}
                render={({ field }) => (
                  <TextField
                    {...field}
                    label="Nombres"
                    fullWidth
                    error={!!errors.nombres}
                    helperText={errors.nombres?.message}
                    InputProps={{
                      startAdornment: (
                        <InputAdornment position="start">
                          <Person color="action" />
                        </InputAdornment>
                      ),
                    }}
                  />
                )}
              />

              <Controller
                name="apellidos"
                control={control}
                rules={{ required: "El apellido es requerido" }}
                render={({ field }) => (
                  <TextField
                    {...field}
                    label="Apellidos"
                    fullWidth
                    error={!!errors.apellidos}
                    helperText={errors.apellidos?.message}
                  />
                )}
              />
            </Box>

            <TextField
              label="Username"
              value={user?.username || ""}
              fullWidth
              disabled
              helperText="El username no puede ser modificado"
              InputProps={{
                startAdornment: (
                  <InputAdornment position="start">
                    <AlternateEmail color="action" />
                  </InputAdornment>
                ),
              }}
            />

            <Controller
              name="email"
              control={control}
              rules={{
                required: "El email es requerido",
                pattern: {
                  value: /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i,
                  message: "Email inválido",
                },
              }}
              render={({ field }) => (
                <TextField
                  {...field}
                  label="Email"
                  type="email"
                  fullWidth
                  error={!!errors.email}
                  helperText={errors.email?.message}
                  InputProps={{
                    startAdornment: (
                      <InputAdornment position="start">
                        <Email color="action" />
                      </InputAdornment>
                    ),
                  }}
                />
              )}
            />

            <Divider sx={{ my: 1 }} />
            <Typography variant="subtitle2" color="text.secondary">
              Cambiar Contraseña (opcional)
            </Typography>

            <Controller
              name="password"
              control={control}
              rules={{
                minLength: {
                  value: 6,
                  message: "La contraseña debe tener al menos 6 caracteres",
                },
              }}
              render={({ field }) => (
                <TextField
                  {...field}
                  label="Nueva Contraseña"
                  type={showPassword ? "text" : "password"}
                  fullWidth
                  error={!!errors.password}
                  helperText={
                    errors.password?.message ||
                    "Dejar vacío para mantener la actual"
                  }
                  InputProps={{
                    startAdornment: (
                      <InputAdornment position="start">
                        <Lock color="action" />
                      </InputAdornment>
                    ),
                    endAdornment: (
                      <InputAdornment position="end">
                        <IconButton
                          onClick={() => setShowPassword(!showPassword)}
                          edge="end"
                        >
                          {showPassword ? <VisibilityOff /> : <Visibility />}
                        </IconButton>
                      </InputAdornment>
                    ),
                  }}
                />
              )}
            />

            <Controller
              name="confirmPassword"
              control={control}
              rules={{
                validate: (value) =>
                  !password ||
                  value === password ||
                  "Las contraseñas no coinciden",
              }}
              render={({ field }) => (
                <TextField
                  {...field}
                  label="Confirmar Contraseña"
                  type={showConfirmPassword ? "text" : "password"}
                  fullWidth
                  error={!!errors.confirmPassword}
                  helperText={errors.confirmPassword?.message}
                  disabled={!password}
                  InputProps={{
                    startAdornment: (
                      <InputAdornment position="start">
                        <Lock color="action" />
                      </InputAdornment>
                    ),
                    endAdornment: (
                      <InputAdornment position="end">
                        <IconButton
                          onClick={() =>
                            setShowConfirmPassword(!showConfirmPassword)
                          }
                          edge="end"
                          disabled={!password}
                        >
                          {showConfirmPassword ? (
                            <VisibilityOff />
                          ) : (
                            <Visibility />
                          )}
                        </IconButton>
                      </InputAdornment>
                    ),
                  }}
                />
              )}
            />

            <Box sx={{ mt: 2, display: "flex", gap: 2 }}>
              <Button
                type="submit"
                variant="contained"
                size="large"
                startIcon={
                  isPending ? (
                    <CircularProgress size={20} color="inherit" />
                  ) : (
                    <Save />
                  )
                }
                disabled={isPending || !isDirty}
                sx={{ minWidth: 200 }}
              >
                {isPending ? "Guardando..." : "Guardar Cambios"}
              </Button>
            </Box>
          </Box>
        </Paper>

        <TutorialesSection />
      </Box>
    </Container>
  );
};

function TutorialesSection() {
  const [, setTick] = useState(0);
  const rerender = () => setTick((t) => t + 1);

  const handleResetOne = (key) => {
    resetTour(key);
    toast.success("Tutorial reiniciado — se mostrará la próxima vez que entres al módulo");
    rerender();
  };

  const handleResetAll = () => {
    resetAllTours();
    toast.success("Todos los tutoriales fueron reiniciados");
    rerender();
  };

  const grupos = TOUR_REGISTRY.reduce((acc, t) => {
    (acc[t.modulo] ||= []).push(t);
    return acc;
  }, {});

  return (
    <Paper sx={{ p: 3, mt: 3 }}>
      <Box sx={{ display: "flex", justifyContent: "space-between", alignItems: "center", mb: 2 }}>
        <Box>
          <Typography variant="h6">Tutoriales</Typography>
          <Typography variant="body2" color="text.secondary">
            Reiniciá un tutorial para que vuelva a abrirse automáticamente la próxima vez que entres al módulo.
          </Typography>
        </Box>
        <Button size="small" variant="outlined" onClick={handleResetAll}>
          Restablecer todos
        </Button>
      </Box>
      <Divider sx={{ mb: 2 }} />
      {Object.entries(grupos).map(([modulo, tours]) => (
        <Box key={modulo} sx={{ mb: 2 }}>
          <Typography
            variant="caption"
            sx={{
              textTransform: "uppercase",
              letterSpacing: 0.5,
              fontWeight: 700,
              color: "text.secondary",
              display: "block",
              mb: 1,
            }}
          >
            {modulo}
          </Typography>
          {tours.map((t) => {
            const done = isTourCompleted(t.key);
            return (
              <Box
                key={t.key}
                sx={{
                  display: "flex",
                  alignItems: "center",
                  justifyContent: "space-between",
                  py: 0.75,
                  borderBottom: "1px solid",
                  borderColor: "divider",
                  "&:last-child": { borderBottom: "none" },
                }}
              >
                <Box sx={{ display: "flex", alignItems: "center", gap: 1.5 }}>
                  <Typography variant="body2">{t.label}</Typography>
                  <Chip
                    size="small"
                    label={done ? "Visto" : "Pendiente"}
                    color={done ? "success" : "default"}
                    variant={done ? "filled" : "outlined"}
                  />
                </Box>
                <Button
                  size="small"
                  variant="text"
                  disabled={!done}
                  onClick={() => handleResetOne(t.key)}
                >
                  Reiniciar
                </Button>
              </Box>
            );
          })}
        </Box>
      ))}
    </Paper>
  );
}

const Container = styled.div`
  min-height: calc(100vh - 80px);
  margin-top: 50px;
  padding: 15px;
`;
