"use client";

import React, { useEffect, useState } from "react";
import { useSession } from "next-auth/react";
import { useRouter } from "next/navigation";
import {
  Box,
  Typography,
  Button,
  CircularProgress,
  Chip,
  Dialog,
  IconButton,
  TextField,
  Stack,
  DialogTitle,
  DialogContent,
  DialogActions,
  Snackbar,
  Alert,
} from "@mui/material";
import CloseIcon from '@mui/icons-material/Close';
import { DataGrid, GridColDef, GridActionsCellItem } from "@mui/x-data-grid";
import EditIcon from "@mui/icons-material/Edit";
import DeleteIcon from "@mui/icons-material/Delete";
import AddIcon from "@mui/icons-material/Add";
import VisibilityIcon from "@mui/icons-material/Visibility";
import { Models } from "../components/ThreeModelView";
import EditModel3DViewer from "../components/GoogleViewer/EditModel3DViewer";
import type { Hotspot } from "../components/GoogleViewer/types";

// interface Model3D {
//   id: number;
//   title: string;
//   category: string;
//   program: string;
//   createdAt: string;
// }

export default function AdminModelsPage() {
  const router = useRouter();
  const [models, setModels] = useState<Models[]>([]);
  const [loading, setLoading] = useState(true);
  const [openModel, setOpenModel] = useState(false);
  const [selectedModel, setSelectedModel] = useState<Models | null>(null);

  // Add/Edit Model Dialog State
  const [openAddEditDialog, setOpenAddEditDialog] = useState(false);
  const [dialogMode, setDialogMode] = useState<"add" | "edit">("add");
  const [formData, setFormData] = useState({
    id: 0,
    title: "",
    description: "",
    speachtext: "",
    image: "",
    modelSrc: "",
    category: "",
    program: "",
    size: "",
    date: "",
  });
  const [formLoading, setFormLoading] = useState(false);

  // Form Validation State
  const [formErrors, setFormErrors] = useState<Record<string, string>>({});
  const [touchedFields, setTouchedFields] = useState<Record<string, boolean>>({});

  // Snackbar State
  const [snackbar, setSnackbar] = useState({
    open: false,
    message: "",
    severity: "success" as "success" | "error" | "warning" | "info",
  });

  // Delete Confirmation State
  const [openDeleteConfirm, setOpenDeleteConfirm] = useState(false);
  const [deleteTarget, setDeleteTarget] = useState<{ id: number; title: string } | null>(null);
  const [deleteLoading, setDeleteLoading] = useState(false);

  const { status } = useSession();

  // Validation helper functions
  const validateField = (name: string, value: string): string => {
    const trimmedValue = value.trim();

    switch (name) {
      case "title":
        if (!trimmedValue) return "Title is required";
        if (trimmedValue.length < 3) return "Title must be at least 3 characters";
        if (trimmedValue.length > 191) return "Title must not exceed 191 characters";
        return "";

      case "description":
        if (!trimmedValue) return "Description is required";
        if (trimmedValue.length < 10) return "Description must be at least 10 characters";
        return "";

      case "speachtext":
        if (value.length > 1000) return "Speech text must not exceed 1000 characters";
        return "";

      case "modelSrc":
        if (!trimmedValue) return "Model source is required";
        const modelExtensions = [".glb", ".gltf", ".obj", ".fbx"];
        const hasValidExt = modelExtensions.some((ext) =>
          trimmedValue.toLowerCase().endsWith(ext)
        );
        if (!hasValidExt)
          return `Model must be one of: ${modelExtensions.join(", ")}`;
        return "";

      case "image":
        if (trimmedValue) {
          const imageExtensions = [".jpg", ".jpeg", ".png", ".webp", ".gif"];
          const hasValidExt = imageExtensions.some((ext) =>
            trimmedValue.toLowerCase().endsWith(ext)
          );
          if (!hasValidExt)
            return `Image must be one of: ${imageExtensions.join(", ")}`;
        }
        return "";

      case "category":
        if (!trimmedValue) return "Category is required";
        if (trimmedValue.length < 2) return "Category must be at least 2 characters";
        return "";

      case "program":
        if (!trimmedValue) return "Program is required";
        if (trimmedValue.length < 2) return "Program must be at least 2 characters";
        return "";

      case "size":
        if (trimmedValue && !/^\d+(\.\d+)?\s*(MB|GB|KB|B)?$/.test(trimmedValue)) {
          return "Size format invalid (e.g., 84.58 MB)";
        }
        return "";

      case "date":
        if (trimmedValue && trimmedValue.length < 3) {
          return "Date format invalid";
        }
        return "";

      default:
        return "";
    }
  };

  const validateForm = (): boolean => {
    const errors: Record<string, string> = {};

    // Validate all fields
    Object.keys(formData).forEach((key) => {
      if (key !== "id") {
        const value = formData[key as keyof typeof formData];
        const error = validateField(key, String(value));
        if (error) errors[key] = error;
      }
    });

    setFormErrors(errors);
    return Object.keys(errors).length === 0;
  };

  const fetchModels = async () => {
    try {
      setLoading(true);
      const res = await fetch("/api/models?page=1&limit=50");
      const data = await res.json();
      setModels(data.data || []);
    } catch (err) {
      console.error("Failed to load models:", err);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (status === "authenticated") {
      fetchModels();
      return;
    }

    if (status === "unauthenticated") {
      router.replace("/admin/login");
    }
  }, [status, router]);

  const handleEdit = (model: Models) => {
    setFormData({
      id: model.id,
      title: model.title || "",
      description: model.description || "",
      speachtext: model.speachtext || "",
      image: model.image || "",
      modelSrc: model.modelSrc || "",
      category: model.category || "",
      program: model.program || "",
      size: model.size || "",
      date: model.date || "",
    });
    setFormErrors({});
    setTouchedFields({});
    setDialogMode("edit");
    setOpenAddEditDialog(true);
  };

  const handleOpenAddDialog = () => {
    setFormData({
      id: 0,
      title: "",
      description: "",
      speachtext: "",
      image: "",
      modelSrc: "",
      category: "",
      program: "",
      size: "",
      date: "",
    });
    setFormErrors({});
    setTouchedFields({});
    setDialogMode("add");
    setOpenAddEditDialog(true);
  };

  const handleCloseDialog = () => {
    setOpenAddEditDialog(false);
    setFormData({
      id: 0,
      title: "",
      description: "",
      speachtext: "",
      image: "",
      modelSrc: "",
      category: "",
      program: "",
      size: "",
      date: "",
    });
    setFormErrors({});
    setTouchedFields({});
  };

  const handleFormChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
    const { name, value } = e.target;
    setFormData((prev) => ({ ...prev, [name]: value }));

    // Real-time validation
    if (touchedFields[name]) {
      const error = validateField(name, value);
      setFormErrors((prev) => {
        if (error) {
          return { ...prev, [name]: error };
        } else {
          const newErrors = { ...prev };
          delete newErrors[name];
          return newErrors;
        }
      });
    }
  };

  const handleFieldBlur = (e: React.FocusEvent<HTMLInputElement | HTMLTextAreaElement>) => {
    const { name } = e.target;
    setTouchedFields((prev) => ({ ...prev, [name]: true }));

    // Validate field on blur
    const value = formData[name as keyof typeof formData];
    const error = validateField(name, String(value));
    setFormErrors((prev) => {
      if (error) {
        return { ...prev, [name]: error };
      } else {
        const newErrors = { ...prev };
        delete newErrors[name];
        return newErrors;
      }
    });
  };

  const handleSubmitForm = async () => {
    // Validate form before submit
    if (!validateForm()) {
      setSnackbar({
        open: true,
        message: "Please enter required fields correctly",
        severity: "error",
      });
      return;
    }

    setFormLoading(true);
    try {
      const url = dialogMode === "add" ? "/api/models" : `/api/models/${formData.id}`;
      const method = dialogMode === "add" ? "POST" : "PUT";

      const response = await fetch(url, {
        method,
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          title: formData.title,
          description: formData.description,
          speachtext: formData.speachtext,
          image: formData.image,
          modelSrc: formData.modelSrc,
          category: formData.category,
          program: formData.program,
          size: formData.size,
          date: formData.date,
        }),
      });

      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}));
        throw new Error(errorData.error || `Failed to ${dialogMode} model`);
      }

      const result = await response.json();
      console.log("Model save response:", result);

      // Update local state
      if (dialogMode === "add") {
        setModels((prev) => [result, ...prev]);
        setSnackbar({
          open: true,
          message: "Model added successfully",
          severity: "success",
        });
      } else {
        setModels((prev) =>
          prev.map((m) => (m.id === formData.id ? result : m))
        );
        setSnackbar({
          open: true,
          message: "Model updated successfully",
          severity: "success",
        });
      }

      handleCloseDialog();
    } catch (error) {
      console.error("Error saving model:", error);
      setSnackbar({
        open: true,
        message: error instanceof Error ? error.message : "Failed to save model",
        severity: "error",
      });
    } finally {
      setFormLoading(false);
    }
  };

  const handleView = (model: Models) => {
    setSelectedModel(model);
    setOpenModel(true);
  };

  const handleDelete = (id: number, title: string) => {
    setDeleteTarget({ id, title });
    setOpenDeleteConfirm(true);
  };

  const handleConfirmDelete = async () => {
    if (!deleteTarget) return;

    setDeleteLoading(true);
    try {
      const response = await fetch(`/api/models/${deleteTarget.id}`, {
        method: "DELETE",
      });

      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}));
        throw new Error(errorData.error || `Failed to delete model (Status: ${response.status})`);
      }

      const result = await response.json();
      console.log("Delete response:", result);

      setModels((prev) => prev.filter((m) => m.id !== deleteTarget.id));
      setSnackbar({
        open: true,
        message: "Model deleted successfully",
        severity: "success",
      });
      setOpenDeleteConfirm(false);
      setDeleteTarget(null);
    } catch (error) {
      console.error("Error deleting model:", error);
      setSnackbar({
        open: true,
        message: error instanceof Error ? error.message : "Failed to delete model",
        severity: "error",
      });
    } finally {
      setDeleteLoading(false);
    }
  };

  const handleCancelDelete = () => {
    setOpenDeleteConfirm(false);
    setDeleteTarget(null);
  };

  const handleHotspotsChange = async (hotspots: Hotspot[]) => {
    if (!selectedModel) return;

    try {
      const oldHotspots = selectedModel.hotspots || [];
      const newHotspots = hotspots;

      const toIdKey = (value: string | number) => String(value);

      // Identify deletions
      const deletedIds = oldHotspots
        .filter((old) => !newHotspots.some((neu) => toIdKey(neu.id) === toIdKey(old.id)))
        .map((h) => h.id);

      // Identify additions
      const addedHotspots = newHotspots.filter(
        (neu) => !oldHotspots.some((old) => toIdKey(old.id) === toIdKey(neu.id))
      );

      // Identify updates
      const updatedHotspots = newHotspots.filter((neu) => {
        const oldHotspot = oldHotspots.find((old) => toIdKey(old.id) === toIdKey(neu.id));
        if (!oldHotspot) return false;
        return (
          neu.title !== oldHotspot.title ||
          neu.description !== oldHotspot.description
        );
      });

      // Delete hotspots
      for (const hotspotId of deletedIds) {
        const numericId = typeof hotspotId === "string" ? parseInt(hotspotId, 10) : hotspotId;
        if (isNaN(numericId)) continue; // Skip draft IDs
        
        await fetch(`/api/models/${selectedModel.id}/hotspots/${numericId}`, {
          method: "DELETE",
        });
      }

      // Create hotspots
      const createdHotspots: Hotspot[] = [];
      for (const hotspot of addedHotspots) {
        const isDraft = typeof hotspot.id === "string" && hotspot.id.startsWith("new-");
        if (!isDraft) continue;

        const res = await fetch(`/api/models/${selectedModel.id}/hotspots`, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            title: hotspot.title,
            description: hotspot.description || null,
            position: hotspot.position,
            normal: hotspot.normal,
          }),
        });

        if (res.ok) {
          const created = await res.json();
          createdHotspots.push({
            id: String(created.id),
            title: created.title,
            description: created.description,
            position: created.position,
            normal: created.normal,
          });
        }
      }

      // Update hotspots
      for (const hotspot of updatedHotspots) {
        const numericId = typeof hotspot.id === "string" ? parseInt(hotspot.id, 10) : hotspot.id;
        if (isNaN(numericId)) continue; // Skip draft IDs

        const updateRes = await fetch(`/api/models/${selectedModel.id}/hotspots/${numericId}`, {
          method: "PUT",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            title: hotspot.title,
            description: hotspot.description || null,
          }),
        });

        if (!updateRes.ok) {
          const errorData = await updateRes.json().catch(() => ({}));
          throw new Error(errorData.error || `Failed to update hotspot ${numericId}`);
        }
      }

      // Update local state with persisted hotspots
      const persistedHotspots = [
        ...updatedHotspots,
        ...createdHotspots,
        ...newHotspots.filter(
          (neu) =>
            !addedHotspots.some((a) => a.id === neu.id) &&
            !updatedHotspots.some((u) => u.id === neu.id)
        ),
      ];

      setSelectedModel((prev) =>
        prev ? { ...prev, hotspots: persistedHotspots } : null
      );

      // Update models list with new hotspots for this model
      setModels((prev) =>
        prev.map((model) =>
          model.id === selectedModel.id
            ? { ...model, hotspots: persistedHotspots }
            : model
        )
      );
    } catch (error) {
      console.error("Error syncing hotspots:", error);
    }
  };

  const columns: GridColDef[] = [
    { 
      field: "title", 
      headerName: "Title", 
      flex: 1,
      minWidth: 200,
      filterable: true,
      sortable: true,
    },
    { 
      field: "category", 
      headerName: "Category", 
      width: 250,
      filterable: true,
      sortable: true,
      renderCell: (params) => (
        <Chip label={params.value} size="small" color="primary" variant="outlined" />
      ),
    },
    { 
      field: "program", 
      headerName: "Program", 
      width: 150,
      filterable: true,
      sortable: true,
    },
    {
      field: "actions",
      type: "actions",
      headerName: "Actions",
      width: 150,
      getActions: (params) => [
        <GridActionsCellItem
          key="view"
          icon={<VisibilityIcon />}
          label="View"
          onClick={() => handleView(params.row)}
          showInMenu={false}
        />,
        <GridActionsCellItem
          key="edit"
          icon={<EditIcon />}
          label="Edit"
          onClick={() => handleEdit(params.row)}
          showInMenu={false}
        />,
        <GridActionsCellItem
          key="delete"
          icon={<DeleteIcon color="error" />}
          label="Delete"
          onClick={() => handleDelete(params.row.id, params.row.title)}
          showInMenu={false}
        />,
      ],
    },
  ];

  if (status === "loading" || (status === "authenticated" && loading && models.length === 0)) {
    return (
      <Box sx={{ display: "flex", justifyContent: "center", mt: 10 }}>
        <CircularProgress />
      </Box>
    );
  }

  if (status === "unauthenticated") {
    return null;
  }

  return (
    <Box sx={{ maxWidth: 1400, margin: "0 auto" }}>
      <Box sx={{ display: "flex", justifyContent: "space-between", mb: 3 }}>
        <Typography variant="h4" sx={{ fontWeight: 700, color: "#171717" }}>
          Model Management
        </Typography>
        <Button
          variant="contained"
          startIcon={<AddIcon />}
          size="small"
          onClick={handleOpenAddDialog}
          sx={{
            backgroundColor: "#6c63ff",
            "&:hover": { backgroundColor: "#554de0" },
          }}
        >
          Add New Model
        </Button>
      </Box>

      <Box sx={{ height: 450, width: "100%", backgroundColor: "#fff", borderRadius: 2 }}>
        <DataGrid
          rows={models}
          rowHeight={40}
          columns={columns}
          loading={loading}
          pageSizeOptions={[10, 25, 50, 100]}
          initialState={{
            pagination: {
              paginationModel: { pageSize: 25, page: 0 },
            },
            sorting: {
              sortModel: [{ field: "createdAt", sort: "desc" }],
            },
          }}
          disableRowSelectionOnClick
          sx={{
            border: "none",
            "& .MuiDataGrid-cell": {
              borderBottom: "1px solid #f0f0f0",
            },
            "& .MuiDataGrid-columnHeaders": {
              backgroundColor: "#f3f4f6",
              borderBottom: "2px solid #e5e7eb",
              fontSize: "0.875rem",
              fontWeight: 600,
            },
            "& .MuiDataGrid-row:hover": {
              backgroundColor: "#f9fafb",
            },
          }}
        />
      </Box>
      {openModel && (
        <Dialog fullScreen open={openModel} onClose={() => setOpenModel(false)} maxWidth="lg" fullWidth>
          <IconButton
          aria-label="close"
          onClick={() => setOpenModel(false)}
          sx={() => ({
            position: 'absolute',
            right: 8,
            top: 8,
            color: '#fff',
            backgroundColor:'#b90f0f',
            '&:hover': {
              backgroundColor: '#950404',
            },
          })}
        >
          <CloseIcon />
        </IconButton>
          <EditModel3DViewer
            modelId={selectedModel?.id || 0}
            src={selectedModel?.modelSrc ? `/assets/${selectedModel.modelSrc}` : ""}
            hotspots={selectedModel?.hotspots || []}
            speachtext={selectedModel?.speachtext}
            title={selectedModel?.title}
            onClose={() => {
              setOpenModel(false);
            }}
            onHotspotsChange={handleHotspotsChange}
          />
        </Dialog>
        )}

      {/* Add/Edit Model Dialog */}
      <Dialog
        open={openAddEditDialog}
        onClose={handleCloseDialog}
        maxWidth="sm"
        fullWidth
        PaperProps={{
          sx: {
            borderRadius: 2,
          },
        }}
      >
        <DialogTitle sx={{ fontWeight: 600, fontSize: "1.25rem" }}>
          {dialogMode === "add" ? "Add New Model" : "Edit Model"}
        </DialogTitle>
        <DialogContent sx={{ pt: 2 }}>
          <Stack spacing={2}>
            <TextField
              label="Title"
              name="title"
              value={formData.title}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              required
              size="small"
              placeholder="Enter model title"
              error={touchedFields.title && !!formErrors.title}
              helperText={touchedFields.title && formErrors.title}
            />
            <TextField
              label="Description"
              name="description"
              value={formData.description}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              required
              multiline
              rows={3}
              size="small"
              placeholder="Enter model description"
              error={touchedFields.description && !!formErrors.description}
              helperText={touchedFields.description && formErrors.description}
            />
            <TextField
              label="Speech Text"
              name="speachtext"
              value={formData.speachtext}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              multiline
              rows={2}
              size="small"
              placeholder="Enter speech text"
              error={touchedFields.speachtext && !!formErrors.speachtext}
              helperText={
                touchedFields.speachtext && formErrors.speachtext
                  ? formErrors.speachtext
                  : `${formData.speachtext.length}/1000`
              }
            />
            <TextField
              label="Model Source (File Path)"
              name="modelSrc"
              value={formData.modelSrc}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              required
              size="small"
              placeholder="e.g., model.glb"
              error={touchedFields.modelSrc && !!formErrors.modelSrc}
              helperText={touchedFields.modelSrc && formErrors.modelSrc ? formErrors.modelSrc : "Supported: .glb, .gltf"}
            />
            <TextField
              label="Image (File Path)"
              name="image"
              value={formData.image}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              size="small"
              placeholder="e.g., image.jpg"
              error={touchedFields.image && !!formErrors.image}
              helperText={touchedFields.image && formErrors.image ? formErrors.image : "Optional - Supported: .jpg, .png, .webp, .gif"}
            />
            <TextField
              label="Subject Category"
              name="category"
              value={formData.category}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              required
              size="small"
              placeholder="Enter subject category"
              error={touchedFields.category && !!formErrors.category}
              helperText={touchedFields.category && formErrors.category}
            />
            <TextField
              label="Group/Class Name"
              name="program"
              value={formData.program}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              required
              size="small"
              placeholder="Enter group/class name"
              error={touchedFields.program && !!formErrors.program}
              helperText={touchedFields.program && formErrors.program}
            />
            {/* <TextField
              label="Size"
              name="size"
              value={formData.size}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              size="small"
              placeholder="e.g., 84.58 MB"
              error={touchedFields.size && !!formErrors.size}
              helperText={touchedFields.size && formErrors.size ? formErrors.size : "Optional - Format: 123 MB"}
            /> */}
            {/* <TextField
              label="Date"
              name="date"
              value={formData.date}
              onChange={handleFormChange}
              onBlur={handleFieldBlur}
              fullWidth
              size="small"
              placeholder="e.g., Jan 28, 2026"
              error={touchedFields.date && !!formErrors.date}
              helperText={touchedFields.date && formErrors.date ? formErrors.date : "Optional"}
            /> */}
          </Stack>
        </DialogContent>
        <DialogActions sx={{ p: 2, gap: 1 }}>
          <Button onClick={handleCloseDialog} variant="outlined">
            Cancel
          </Button>
          <Button
            onClick={handleSubmitForm}
            variant="contained"
            disabled={formLoading || Object.keys(formErrors).length > 0}
            sx={{
              backgroundColor: "#6c63ff",
              "&:hover": { backgroundColor: "#554de0" },
              "&:disabled": { backgroundColor: "#ccc", color: "#999" },
            }}
          >
            {formLoading ? <CircularProgress size={20} sx={{ mr: 1 }} /> : null}
            {dialogMode === "add" ? "Add Model" : "Update Model"}
          </Button>
        </DialogActions>
      </Dialog>

      {/* Delete Confirmation Dialog */}
      <Dialog
        open={openDeleteConfirm}
        onClose={handleCancelDelete}
        maxWidth="sm"
        fullWidth
        PaperProps={{
          sx: {
            borderRadius: 2,
          },
        }}
      >
        <DialogTitle sx={{ fontWeight: 600, fontSize: "1.1rem" }}>
          Delete Model
        </DialogTitle>
        <DialogContent sx={{ pt: 2 }}>
          <Typography sx={{ mb: 2 }}>
            Are you sure you want to delete this model?
          </Typography>
          {deleteTarget && (
            <Box
              sx={{
                backgroundColor: "#f5f5f5",
                padding: 2,
                borderRadius: 1,
                borderLeft: "4px solid #d32f2f",
              }}
            >
              <Typography variant="body2" sx={{ color: "#666" }}>
                <strong>Model:</strong> {deleteTarget.title}
              </Typography>
              <Typography
                variant="body2"
                sx={{ color: "#999", mt: 1, fontSize: "0.875rem" }}
              >
                This action cannot be undone. All associated hotspots will also be deleted.
              </Typography>
            </Box>
          )}
        </DialogContent>
        <DialogActions sx={{ p: 2, gap: 1 }}>
          <Button
            onClick={handleCancelDelete}
            variant="outlined"
            disabled={deleteLoading}
          >
            Cancel
          </Button>
          <Button
            onClick={handleConfirmDelete}
            variant="contained"
            disabled={deleteLoading}
            sx={{
              backgroundColor: "#d32f2f",
              "&:hover": { backgroundColor: "#b71c1c" },
              "&:disabled": { backgroundColor: "#ccc", color: "#999" },
            }}
          >
            {deleteLoading ? (
              <>
                <CircularProgress size={20} sx={{ mr: 1 }} />
                Deleting...
              </>
            ) : (
              <>
                <DeleteIcon sx={{ mr: 1, fontSize: "1.2rem" }} />
                Delete
              </>
            )}
          </Button>
        </DialogActions>
      </Dialog>

      {/* Snackbar for Messages */}
      <Snackbar
        open={snackbar.open}
        autoHideDuration={6000}
        onClose={() => setSnackbar({ ...snackbar, open: false })}
        anchorOrigin={{ vertical: "top", horizontal: "right" }}
      >
        <Alert
          onClose={() => setSnackbar({ ...snackbar, open: false })}
          severity={snackbar.severity}
          sx={{ width: "100%", borderRadius: 1 }}
        >
          {snackbar.message}
        </Alert>
      </Snackbar>
    </Box>
  );
}
