import { Users } from 'lucide-react';
import { toast } from 'sonner';

import { useEffect, useState } from 'react';

import { Head, useForm, router } from '@inertiajs/react';

import { Badge } from '@/Components/ui/badge';
import { Button } from '@/Components/ui/button';
import { EmptyState } from '@/Components/ui/empty-state';
import { Input } from '@/Components/ui/input';
import { Label } from '@/Components/ui/label';
import { LoadingButton } from '@/Components/ui/loading-button';
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/Components/ui/select';
import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
} from '@/Components/ui/table';
import DashboardLayout from '@/Layouts/DashboardLayout';
import { trackEvent } from '@/lib/analytics';
import { TEAM_MANAGEMENT_VIEWED } from '@/lib/event-catalog';
import { formatDateOnly } from '@/lib/format';

type SiteRole = 'viewer' | 'editor' | 'admin';

interface SiteUser {
  id: number;
  name: string;
  email: string;
}

interface Member {
  id: number;
  user: SiteUser;
  role: SiteRole;
  accepted_at: string;
}

interface PendingMember {
  id: number;
  user: SiteUser | null;
  role: SiteRole;
  token_expires_at: string;
  invited_by: SiteUser | null;
}

interface TeamSite {
  id: number;
  name: string;
}

interface Props {
  site: TeamSite;
  members: Member[];
  pending: PendingMember[];
  roles: string[];
}

const roleBadgeClass: Record<SiteRole, string> = {
  viewer: 'bg-muted text-muted-foreground',
  editor: 'bg-info/10 text-info',
  admin: 'bg-primary/10 text-primary',
};

function RoleBadge({ role }: { role: SiteRole }) {
  return (
    <Badge className={roleBadgeClass[role]}>{role.charAt(0).toUpperCase() + role.slice(1)}</Badge>
  );
}

function UserInitials({ name }: { name: string }) {
  const initials = name
    .split(' ')
    .map((part) => part[0])
    .slice(0, 2)
    .join('')
    .toUpperCase();
  return (
    <div className="flex h-8 w-8 items-center justify-center rounded-full bg-primary text-xs font-medium text-primary-foreground">
      {initials}
    </div>
  );
}

export default function Team({ site, members, pending, roles }: Props) {
  useEffect(() => {
    trackEvent(TEAM_MANAGEMENT_VIEWED, { site_id: String(site.id) });
  }, [site.id]);

  const [confirmingRemove, setConfirmingRemove] = useState<number | null>(null);

  const inviteForm = useForm({
    email: '',
    role: 'viewer' as SiteRole,
  });

  const roleChangeForm = useForm({
    role: '' as SiteRole,
  });

  function submitInvite(e: React.FormEvent) {
    e.preventDefault();
    inviteForm.post(route('site-members.store', site.id), {
      onSuccess: () => {
        inviteForm.reset();
        toast.success('Invitation sent.');
      },
    });
  }

  function changeRole(member: Member, newRole: SiteRole) {
    roleChangeForm.setData('role', newRole);
    roleChangeForm.patch(route('site-members.update', [site.id, member.id]), {
      onSuccess: () => toast.success(`${member.user.name}'s role updated to ${newRole}.`),
    });
  }

  function revokeMember(memberId: number) {
    router.delete(route('site-members.destroy', [site.id, memberId]), {
      onSuccess: () => toast.success('Team member removed.'),
      onFinish: () => setConfirmingRemove(null),
    });
  }

  return (
    <DashboardLayout>
      <Head title={`Team — ${site.name}`} />

      <div className="mx-auto max-w-3xl space-y-8 p-6">
        <div>
          <h1 className="text-2xl font-semibold text-foreground">Team Members</h1>
          <p className="mt-1 text-sm text-muted-foreground">
            Manage who has access to <strong>{site.name}</strong>.
          </p>
        </div>

        {/* ── Active Members ── */}
        <section>
          <h2 className="mb-3 text-base font-medium text-foreground">Members</h2>
          {members.length === 0 ? (
            <EmptyState
              icon={Users}
              title="No team members yet"
              description="Invite colleagues to collaborate on this site using the form below."
            />
          ) : (
            <div className="overflow-x-auto rounded-md border">
              <Table>
                <TableHeader>
                  <TableRow>
                    <TableHead>Member</TableHead>
                    <TableHead>Role</TableHead>
                    <TableHead className="w-40">Change Role</TableHead>
                    <TableHead className="w-24" />
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {members.map((member) => (
                    <TableRow key={member.id}>
                      <TableCell>
                        <div className="flex items-center gap-3">
                          <UserInitials name={member.user.name} />
                          <div>
                            <p className="text-sm font-medium text-foreground">
                              {member.user.name}
                            </p>
                            <p className="text-xs text-muted-foreground">{member.user.email}</p>
                          </div>
                        </div>
                      </TableCell>
                      <TableCell>
                        <RoleBadge role={member.role} />
                      </TableCell>
                      <TableCell>
                        <Select
                          defaultValue={member.role}
                          onValueChange={(val) => changeRole(member, val as SiteRole)}
                          disabled={roleChangeForm.processing}
                        >
                          <SelectTrigger className="h-8 w-32">
                            <SelectValue />
                          </SelectTrigger>
                          <SelectContent>
                            {roles.map((r) => (
                              <SelectItem key={r} value={r}>
                                {r.charAt(0).toUpperCase() + r.slice(1)}
                              </SelectItem>
                            ))}
                          </SelectContent>
                        </Select>
                      </TableCell>
                      <TableCell>
                        {confirmingRemove === member.id ? (
                          <div className="flex gap-2">
                            <Button
                              size="sm"
                              variant="destructive"
                              onClick={() => revokeMember(member.id)}
                            >
                              Confirm
                            </Button>
                            <Button
                              size="sm"
                              variant="ghost"
                              onClick={() => setConfirmingRemove(null)}
                            >
                              Cancel
                            </Button>
                          </div>
                        ) : (
                          <Button
                            size="sm"
                            variant="ghost"
                            className="text-destructive hover:text-destructive"
                            onClick={() => setConfirmingRemove(member.id)}
                          >
                            Remove
                          </Button>
                        )}
                      </TableCell>
                    </TableRow>
                  ))}
                </TableBody>
              </Table>
            </div>
          )}
        </section>

        {/* ── Pending Invitations ── */}
        {pending.length > 0 && (
          <section>
            <h2 className="mb-3 text-base font-medium text-foreground">Pending Invitations</h2>
            <div className="overflow-x-auto rounded-md border">
              <Table>
                <TableHeader>
                  <TableRow>
                    <TableHead>Email</TableHead>
                    <TableHead>Role</TableHead>
                    <TableHead>Expires</TableHead>
                    <TableHead className="w-24" />
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {pending.map((invite) => (
                    <TableRow key={invite.id}>
                      <TableCell className="text-sm text-muted-foreground">
                        {invite.user?.email ?? 'Unknown'}
                      </TableCell>
                      <TableCell>
                        <RoleBadge role={invite.role} />
                      </TableCell>
                      <TableCell className="text-sm text-muted-foreground">
                        {formatDateOnly(invite.token_expires_at)}
                      </TableCell>
                      <TableCell>
                        <Button
                          size="sm"
                          variant="ghost"
                          className="text-destructive hover:text-destructive"
                          onClick={() => revokeMember(invite.id)}
                        >
                          Revoke
                        </Button>
                      </TableCell>
                    </TableRow>
                  ))}
                </TableBody>
              </Table>
            </div>
          </section>
        )}

        {/* ── Invite Form ── */}
        <section>
          <h2 className="mb-3 text-base font-medium text-foreground">Invite Member</h2>
          <form onSubmit={submitInvite} className="flex flex-col gap-4 sm:flex-row sm:items-end">
            <div className="flex-1 space-y-1">
              <Label htmlFor="invite-email">Email address</Label>
              <Input
                id="invite-email"
                type="email"
                placeholder="colleague@example.com"
                value={inviteForm.data.email}
                onChange={(e) => inviteForm.setData('email', e.target.value)}
                className={inviteForm.errors.email ? 'border-destructive' : ''}
              />
              {inviteForm.errors.email && (
                <p className="text-xs text-destructive">{inviteForm.errors.email}</p>
              )}
            </div>

            <div className="w-40 space-y-1">
              <Label htmlFor="invite-role">Role</Label>
              <Select
                value={inviteForm.data.role}
                onValueChange={(val) => inviteForm.setData('role', val as SiteRole)}
              >
                <SelectTrigger id="invite-role">
                  <SelectValue />
                </SelectTrigger>
                <SelectContent>
                  {roles.map((r) => (
                    <SelectItem key={r} value={r}>
                      {r.charAt(0).toUpperCase() + r.slice(1)}
                    </SelectItem>
                  ))}
                </SelectContent>
              </Select>
            </div>

            <LoadingButton type="submit" loading={inviteForm.processing} className="sm:self-end">
              Send Invite
            </LoadingButton>
          </form>
        </section>
      </div>
    </DashboardLayout>
  );
}
