"use client";

import React, { useEffect, useState } from "react";
import {
  Box,
  Typography,
  Button,
  CircularProgress,
  Chip,
  Dialog,
  DialogTitle,
  DialogContent,
  DialogActions,
  TextField,
  MenuItem,
} from "@mui/material";
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 { useSession } from "next-auth/react";
import { useRouter } from "next/navigation";

interface UserData {
  id: number;
  name: string | null;
  email: string;
  role: string;
  createdAt: string;
}

export default function AdminUsersPage() {
  const { status } = useSession();
  const router = useRouter();
  const [users, setUsers] = useState<UserData[]>([]);
  const [loading, setLoading] = useState(true);

  // Dialog State
  const [open, setOpen] = useState(false);
  const [editId, setEditId] = useState<number | null>(null);
  
  // Form fields
  const [name, setName] = useState("");
  const [email, setEmail] = useState("");
  const [password, setPassword] = useState("");
  const [role, setRole] = useState("USER");
  const [submitting, setSubmitting] = useState(false);

  const fetchUsers = async () => {
    try {
      setLoading(true);
      const res = await fetch("/api/users?page=1&limit=50");
      const data = await res.json();
      setUsers(data.data || []);
    } catch (err) {
      console.error("Failed to load users:", err);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (status === "authenticated") {
      fetchUsers();
    } else if (status === "unauthenticated") {
      router.replace("/admin/login");
    }
  }, [status, router]);

  const handleOpenAdd = () => {
    setEditId(null);
    setName("");
    setEmail("");
    setPassword("");
    setRole("USER");
    setOpen(true);
  };

  const handleOpenEdit = (user: UserData) => {
    setEditId(user.id);
    setName(user.name || "");
    setEmail(user.email);
    setPassword(""); // Keep password empty, only update if submitted
    setRole(user.role || "USER");
    setOpen(true);
  };

  const handleClose = () => {
    setOpen(false);
  };

  const handleSubmit = async () => {
    setSubmitting(true);

    try {
      const payload = {
        name,
        email,
        role,
        ...(password ? { password } : {}),
      };

      const endpoint = editId ? `/api/users/${editId}` : "/api/users";
      const method = editId ? "PUT" : "POST";

      const res = await fetch(endpoint, {
        method,
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
      });

      if (!res.ok) {
        const errorData = await res.json();
        alert(errorData.error || "Failed to save user");
        return;
      }

      await fetchUsers();
      handleClose();
    } catch (err) {
      console.error("Submit error:", err);
      alert("An error occurred");
    } finally {
      setSubmitting(false);
    }
  };

  const handleDelete = async (id: number) => {
    if (confirm("Are you sure you want to delete this user?")) {
      try {
        const res = await fetch(`/api/users/${id}`, { method: "DELETE" });
        if (res.ok) {
          setUsers(users.filter((u) => u.id !== id));
        } else {
          alert("Failed to delete user");
        }
      } catch (err) {
        console.error("Delete error:", err);
      }
    }
  };

  const columns: GridColDef[] = [
    { 
      field: "id", 
      headerName: "ID", 
      width: 80,
      filterable: true,
      sortable: true,
    },
    { 
      field: "name", 
      headerName: "Name", 
      flex: 1,
      minWidth: 150,
      filterable: true,
      sortable: true,
      valueGetter: (value) => value || "N/A",
    },
    { 
      field: "email", 
      headerName: "Email", 
      flex: 1,
      minWidth: 200,
      filterable: true,
      sortable: true,
    },
    { 
      field: "role", 
      headerName: "Role", 
      width: 130,
      filterable: true,
      sortable: true,
      renderCell: (params) => (
        <Chip 
          label={params.value} 
          size="small" 
          color={params.value === "ADMIN" ? "secondary" : "default"}
          sx={params.value === "ADMIN" ? { backgroundColor: "#6c63ff", color: "white" } : {}}
        />
      ),
    },
    { 
      field: "createdAt", 
      headerName: "Date Created", 
      width: 150,
      filterable: true,
      sortable: true,
      valueFormatter: (value) => {
        return new Date(value).toLocaleDateString();
      },
    },
    {
      field: "actions",
      type: "actions",
      headerName: "Actions",
      width: 120,
      getActions: (params) => [
        <GridActionsCellItem
          key="edit"
          icon={<EditIcon />}
          label="Edit"
          onClick={() => handleOpenEdit(params.row)}
          showInMenu={false}
        />,
        <GridActionsCellItem
          key="delete"
          icon={<DeleteIcon color="error" />}
          label="Delete"
          onClick={() => handleDelete(params.row.id)}
          showInMenu={false}
        />,
      ],
    },
  ];

  if (status === "loading") {
    return (
      <Box sx={{ display: "flex", justifyContent: "center", mt: 10 }}>
        <CircularProgress />
      </Box>
    );
  }

  return (
    <Box sx={{ maxWidth: 1400, margin: "0 auto" }}>
      <Box sx={{ display: "flex", justifyContent: "space-between", mb: 3 }}>
        <Typography variant="h4" component={'h4'} sx={{ fontWeight: 700, color: "#171717" }}>
          User Management
        </Typography>
        <Button
          variant="contained"
          startIcon={<AddIcon />}
          onClick={handleOpenAdd}
          size="small"
          sx={{
            backgroundColor: "#6c63ff",
            "&:hover": { backgroundColor: "#554de0" },
          }}
        >
          Add New User
        </Button>
      </Box>

      <Box sx={{ height: 450, width: "100%", backgroundColor: "#fff", borderRadius: 2 }}>
        <DataGrid
          rows={users}
          columns={columns}
          loading={loading}
          rowHeight={40}
          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>

      {/* Add / Edit Dialog */}
      <Dialog open={open} onClose={handleClose} maxWidth="sm" fullWidth>
        <DialogTitle>{editId ? "Edit User" : "Add New User"}</DialogTitle>
        <DialogContent dividers>
          <Box sx={{ display: "flex", flexDirection: "column", gap: 3, mt: 1 }}>
            <TextField
              label="Name"
              variant="outlined"
              fullWidth
              value={name}
              onChange={(e) => setName(e.target.value)}
            />
            <TextField
              label="Email"
              variant="outlined"
              fullWidth
              required
              value={email}
              onChange={(e) => setEmail(e.target.value)}
            />
            <TextField
              label={editId ? "Password (leave blank to keep current)" : "Password"}
              type="password"
              variant="outlined"
              fullWidth
              required={!editId}
              value={password}
              onChange={(e) => setPassword(e.target.value)}
            />
            <TextField
              select
              label="Role"
              value={role}
              onChange={(e) => setRole(e.target.value)}
              fullWidth
              variant="outlined"
            >
              <MenuItem value="USER">User</MenuItem>
              <MenuItem value="ADMIN">Admin</MenuItem>
            </TextField>
          </Box>
        </DialogContent>
        <DialogActions sx={{ px: 3, py: 2 }}>
          <Button onClick={handleClose} color="inherit">
            Cancel
          </Button>
          <Button
            onClick={handleSubmit}
            variant="contained"
            disabled={submitting}
            sx={{
              backgroundColor: "#6c63ff",
              "&:hover": { backgroundColor: "#554de0" },
            }}
          >
            {submitting ? "Saving..." : "Save"}
          </Button>
        </DialogActions>
      </Dialog>
    </Box>
  );
}
