'use client';

import { useEffect } from 'react';
import { useParams, useRouter } from 'next/navigation';
import {
  createPackage,
  fetchPackage,
  updatePackage,
} from '@/network/apis/dashboard/packages/packages.apis.';
import { zodResolver } from '@hookform/resolvers/zod';
import { RiCheckboxCircleFill, RiErrorWarningFill } from '@remixicon/react';
import { useMutation, useQuery } from '@tanstack/react-query';
import { useFieldArray, useForm } from 'react-hook-form';
import { toast } from 'sonner';
import { Alert, AlertIcon, AlertTitle } from '@/components/ui/alert';
import { Button } from '@/components/ui/button';
import {
  Form,
  FormControl,
  FormField,
  FormItem,
  FormLabel,
  FormMessage,
} from '@/components/ui/form';
import { Input } from '@/components/ui/input';
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/components/ui/select';
import { Separator } from '@/components/ui/separator';
import { Spinner } from '@/components/ui/spinners';
import { Switch } from '@/components/ui/switch';
import { PackageAddSchema, PackageAddSchemaType } from './package-add-schema';

const PackageAdd = () => {
  const router = useRouter();
  const params = useParams();
  const id = params?.slug?.[0] ? Number(params?.slug?.[0]) : undefined;

  const { data: package_details } = useQuery({
    queryKey: ['package_details', id],
    queryFn: async () => {
      if (id === undefined) return;
      return await fetchPackage({ id });
    },
    enabled: id !== undefined,
  });

  const form = useForm<PackageAddSchemaType>({
    resolver: zodResolver(PackageAddSchema),
    defaultValues: {
      name: '',
      description: '',
      price: 0,
      duration_in_days: 0,
      number_of_requests: 0,
      search_balance: 0,
      social_listening_balance: 0,
      lookalike_balance: 0,
      mynetwork_balance: 0,
      campaign_balance: 0,
      competitor_analysis_balance: 0,
      is_active: 1 as 0 | 1,
      platforms: [],
    },
    mode: 'onSubmit',
  });

  const {
    formState: { errors },
  } = form;

  const platformsError =
    errors.platforms?.message ?? errors.platforms?.root?.message;

  const { fields, append, remove } = useFieldArray({
    control: form.control,
    name: 'platforms',
  });

  useEffect(() => {
    if (package_details) {
      const normalized = {
        ...package_details,
        is_active:
          typeof package_details.is_active === 'boolean'
            ? package_details.is_active
              ? 1
              : 0
            : (package_details.is_active ?? 1),
        search_balance: package_details.search_balance ?? 0,
        social_listening_balance: package_details.social_listening_balance ?? 0,
        lookalike_balance: package_details.lookalike_balance ?? 0,
        mynetwork_balance: package_details.mynetwork_balance ?? 0,
        campaign_balance: package_details.campaign_balance ?? 0,
        competitor_analysis_balance: package_details.competitor_analysis_balance ?? 0,
        platforms: package_details.platforms ?? [],
      } as PackageAddSchemaType;

      form.reset(normalized);
    }
  }, [package_details, form]);

  const mutation = useMutation({
    mutationFn: async (values: PackageAddSchemaType) => {
      if (id) {
        const payload = { id, ...values };
        return updatePackage(payload);
      }
      return createPackage(values);
    },
    onSuccess: () => {
      toast.custom(
        () => (
          <Alert variant="mono" icon="success" close={false}>
            <AlertIcon>
              <RiCheckboxCircleFill />
            </AlertIcon>
            <AlertTitle>
              {id
                ? 'Package updated successfully'
                : 'Package added successfully'}
            </AlertTitle>
          </Alert>
        ),
        { position: 'top-center' },
      );
      router.push('/packages');
    },
    onError: (error: Error) => {
      toast.custom(
        () => (
          <Alert variant="mono" icon="destructive" close={false}>
            <AlertIcon>
              <RiErrorWarningFill />
            </AlertIcon>
            <AlertTitle>{error.message}</AlertTitle>
          </Alert>
        ),
        { position: 'top-center' },
      );
    },
  });

  const isProcessing = mutation.status === 'pending';

  const handleSubmit = (values: PackageAddSchemaType) => {
    mutation.mutate(values);
  };

  const platforms = [
    { value: 1, label: 'Snapchat' },
    { value: 2, label: 'Tiktok' },
    { value: 3, label: 'Instagram' },
    { value: 4, label: 'Youtube' },
    { value: 5, label: 'X Twitter' },
    { value: 6, label: 'Twitch' },
  ];

  const platformFilters = {
    snapchat: {
      influencer: [
        { label: 'influencerSize' },
        { label: 'influencerLocation' },
        { label: 'categorySearch' },
        { label: 'internal_profile_category' },
        { label: 'profile_tier' },
        { label: 'contactInformation' },
        { label: 'websiteInformation' },
        { label: 'keywords' },
      ],
      audience: [
        { label: 'audienceLocation' },
        { label: 'audienceGender' },
        { label: 'audienceAge' },
        { label: 'operating_system' },
        { label: 'audience_location_screenshots' },
        { label: 'audience_location_shares' },
        { label: 'audience_location_swipe_downs' },
        { label: 'audience_location_swipe_ups' },
        { label: 'audience_location_replies' },
        { label: 'audience_gender_screenshots' },
        { label: 'audience_gender_shares' },
        { label: 'audience_gender_swipe_downs' },
        { label: 'audience_gender_swipe_ups' },
        { label: 'audience_gender_replies' },
        { label: 'audience_age_screenshots' },
        { label: 'audience_age_shares' },
        { label: 'audience_age_swipe_downs' },
        { label: 'audience_age_swipe_ups' },
        { label: 'audience_age_replies' },
      ],
      performance: [
        { label: 'profile_er' },
        { label: 'lenses_er' },
        { label: 'snaps_er' },
        { label: 'spotlights_er' },
        { label: 'stories_er' },
        { label: 'profile_views' },
        { label: 'spotlight_replies' },
        { label: 'spotlight_shares' },
      ],
    },
    instagram: {
      influencer: [
        { label: 'influencerSize' },
        { label: 'influencerGender' },
        { label: 'accountType' },
        { label: 'influencerLocation' },
        { label: 'influencerLanguage' },
        { label: 'influencerAge' },
        { label: 'verified' },
        { label: 'contactInformation' },
        { label: 'ai_search' },
        { label: 'keywords' },
        { label: 'estimatedPostPrice' },
        { label: 'excludeLists' },
      ],
      audience: [
        { label: 'audienceQualityResult' },
        { label: 'audienceLocation' },
        { label: 'audienceGender' },
        { label: 'audienceAge' },
        { label: 'audienceInterests' },
        { label: 'audienceEthnicity' },
        { label: 'audienceIncome' },
      ],
      performance: [
        { label: 'avgReelsViews90d' },
        { label: 'erPercentage' },
        { label: 'commentRate' },
        { label: 'follower_growth' },
        { label: 'brand_mentions180d' },
        { label: 'most_recent_post' },
        { label: 'similarTo' },
      ],
    },
    youtube: {
      influencer: [
        { label: 'influencerSize' },
        { label: 'influencerLocation' },
        { label: 'influencerLanguage' },
        { label: 'verified' },
        { label: 'contactInformation' },
        { label: 'ai_search' },
        { label: 'keywords' },
        { label: 'estimatedPostPrice' },
        { label: 'excludeLists' },
      ],
      audience: [
        { label: 'channel_quality_score' },
        { label: 'audienceLocation' },
        { label: 'audienceGender' },
        { label: 'audienceAge' },
      ],
      performance: [
        { label: 'avg_views_per_video' },
        { label: 'avg_shorts_views90d' },
        { label: 'erPercentage' },
        { label: 'avg_comments_per_video' },
        { label: 'avg_reactions_per_video' },
        { label: 'commentRate' },
        { label: 'reactionRate' },
        { label: 'subscribers_growth' },
        { label: 'media_count' },
        { label: 'content_type' },
        { label: 'accounts_mentions180d' },
        { label: 'most_recent_post' },
        { label: 'similarTo' },
      ],
    },
    tiktok: {
      influencer: [
        { label: 'influencerSize' },
        { label: 'influencerGender' },
        { label: 'influencerLocation' },
        { label: 'influencerLanguage' },
        { label: 'verified' },
        { label: 'contactInformation' },
        { label: 'ai_search' },
        { label: 'keywords' },
        { label: 'estimatedPostPrice' },
        { label: 'excludeLists' },
      ],
      audience: [
        { label: 'account_quality_score' },
        { label: 'audienceLocation' },
        { label: 'audienceGender' },
        { label: 'audienceAge' },
      ],
      performance: [
        { label: 'views_avg' },
        { label: 'erPercentage' },
        { label: 'avg_likes_30d' },
        { label: 'avg_comments_30d' },
        { label: 'avg_shares_30d' },
        { label: 'likes_growth' },
        { label: 'follower_growth' },
        { label: 'total_likes' },
        { label: 'brand_mentions180d' },
        { label: 'most_recent_post' },
        { label: 'similarTo' },
      ],
    },
    twitter: {
      influencer: [
        { label: 'influencerSize' },
        { label: 'influencerLocation' },
        { label: 'influencerLanguage' },
        { label: 'verified' },
        { label: 'contactInformation' },
        { label: 'keywords' },
        { label: 'excludeLists' },
      ],
      audience: [],
      performance: [
        { label: 'erPercentage', tooltip: 'erPercentage_twitter_tooltip' },
        { label: 'follower_growth' },
        { label: 'most_recent_post' },
        { label: 'avg_posts_30d' },
        { label: 'avg_replies_30d' },
        { label: 'avg_likes_twitter_30d' },
        { label: 'avg_reposts_30d' },
      ],
    },
    twitch: {
      influencer: [
        { label: 'influencerSize' },
        { label: 'influencerLanguage' },
        { label: 'contactInformation' },
        { label: 'keywords' },
        { label: 'excludeLists' },
      ],
      audience: [{ label: 'audienceLocation' }, { label: 'audienceGender' }],
      performance: [
        { label: 'follower_growth' },
        { label: 'avg_live_viewers' },
        { label: 'active_days_per_week' },
        { label: 'games_played' },
      ],
    },
  };

  const platformNames: Record<number, keyof typeof platformFilters> = {
    1: 'snapchat',
    2: 'tiktok',
    3: 'instagram',
    4: 'youtube',
    5: 'twitter',
    6: 'twitch',
  };

  const formatFilterLabel = (label: string) => {
    return label
      .replace(/([a-z])([A-Z])/g, '$1 $2')
      .replace(/_/g, ' ')
      .replace(/\b\w/g, (l) => l.toUpperCase());
  };

  return (
    <div className="p-10">
      <Form {...form}>
        <form className="w-full" onSubmit={form.handleSubmit(handleSubmit)}>
          <div className="flex justify-between mb-5">
            <p className="font-bold text-2xl">
              {id ? 'Update Package' : 'Create Package'}
            </p>
            <FormField
              control={form.control}
              name="is_active"
              render={({ field }) => (
                <FormItem className="flex items-center space-x-2">
                  <FormLabel htmlFor="is_active">Status</FormLabel>
                  <FormControl>
                    <Switch
                      id="is_active"
                      checked={field.value === 1}
                      onCheckedChange={(checked) =>
                        field.onChange(checked ? 1 : 0)
                      }
                    />
                  </FormControl>
                </FormItem>
              )}
            />
          </div>

          <div className="grid grid-cols-2 gap-4 mb-5">
            <FormField
              control={form.control}
              name="name"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Package Name</FormLabel>
                  <FormControl>
                    <Input placeholder="Enter package name" {...field} />
                  </FormControl>
                  <FormMessage />
                </FormItem>
              )}
            />
            <FormField
              control={form.control}
              name="price"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Price</FormLabel>
                  <FormControl>
                    <Input
                      type="number"
                      placeholder="Enter price"
                      value={field.value}
                      onChange={(e) => field.onChange(Number(e.target.value))}
                    />
                  </FormControl>
                  <FormMessage />
                </FormItem>
              )}
            />
          </div>

          <div className="grid grid-cols-2 gap-4 mb-5">
            <FormField
              control={form.control}
              name="duration_in_days"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Duration in Days</FormLabel>
                  <FormControl>
                    <Input
                      type="number"
                      placeholder="Enter duration"
                      value={field.value}
                      onChange={(e) => field.onChange(Number(e.target.value))}
                    />
                  </FormControl>
                  <FormMessage />
                </FormItem>
              )}
            />
            <FormField
              control={form.control}
              name="number_of_requests"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Number of Requests</FormLabel>
                  <FormControl>
                    <Input
                      type="number"
                      placeholder="Enter number of requests"
                      value={field.value}
                      onChange={(e) => field.onChange(Number(e.target.value))}
                    />
                  </FormControl>
                  <FormMessage />
                </FormItem>
              )}
            />
          </div>

          <FormField
            control={form.control}
            name="description"
            render={({ field }) => (
              <FormItem className="mb-8">
                <FormLabel>Description</FormLabel>
                <FormControl>
                  <Input placeholder="Enter description" {...field} />
                </FormControl>
                <FormMessage />
              </FormItem>
            )}
          />

          <div className="mb-8">
            <div className="flex items-center gap-2 mb-4">
              <h3 className="text-lg font-bold">Balance Allocations</h3>
              <span className="text-xs text-muted-foreground bg-muted px-2 py-0.5 rounded-full">
                Auto-credited on subscription
              </span>
            </div>
            <p className="text-sm text-muted-foreground mb-4">
              Set balance limits for each service type. These balances are automatically credited to the client when they subscribe to this package.
            </p>
            <div className="grid grid-cols-2 md:grid-cols-3 gap-4">
              <FormField
                control={form.control}
                name="search_balance"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>Search Balance</FormLabel>
                    <FormControl>
                      <Input
                        type="number"
                        min={0}
                        placeholder="0"
                        value={field.value ?? 0}
                        onChange={(e) => field.onChange(Number(e.target.value))}
                      />
                    </FormControl>
                    <FormMessage />
                  </FormItem>
                )}
              />
              <FormField
                control={form.control}
                name="social_listening_balance"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>Social Listening</FormLabel>
                    <FormControl>
                      <Input
                        type="number"
                        min={0}
                        placeholder="0"
                        value={field.value ?? 0}
                        onChange={(e) => field.onChange(Number(e.target.value))}
                      />
                    </FormControl>
                    <FormMessage />
                  </FormItem>
                )}
              />
              <FormField
                control={form.control}
                name="lookalike_balance"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>Lookalike</FormLabel>
                    <FormControl>
                      <Input
                        type="number"
                        min={0}
                        placeholder="0"
                        value={field.value ?? 0}
                        onChange={(e) => field.onChange(Number(e.target.value))}
                      />
                    </FormControl>
                    <FormMessage />
                  </FormItem>
                )}
              />
              <FormField
                control={form.control}
                name="mynetwork_balance"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>My Network</FormLabel>
                    <FormControl>
                      <Input
                        type="number"
                        min={0}
                        placeholder="0"
                        value={field.value ?? 0}
                        onChange={(e) => field.onChange(Number(e.target.value))}
                      />
                    </FormControl>
                    <FormMessage />
                  </FormItem>
                )}
              />
              <FormField
                control={form.control}
                name="campaign_balance"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>Campaign Mgmt</FormLabel>
                    <FormControl>
                      <Input
                        type="number"
                        min={0}
                        placeholder="0"
                        value={field.value ?? 0}
                        onChange={(e) => field.onChange(Number(e.target.value))}
                      />
                    </FormControl>
                    <FormMessage />
                  </FormItem>
                )}
              />
              <FormField
                control={form.control}
                name="competitor_analysis_balance"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>Competitor Analysis</FormLabel>
                    <FormControl>
                      <Input
                        type="number"
                        min={0}
                        placeholder="0"
                        value={field.value ?? 0}
                        onChange={(e) => field.onChange(Number(e.target.value))}
                      />
                    </FormControl>
                    <FormMessage />
                  </FormItem>
                )}
              />
            </div>
          </div>

          <div className="flex justify-between items-center mb-4">
            <h3 className="text-lg font-bold">Platforms</h3>
            <Button
              type="button"
              variant="outline"
              onClick={() =>
                append({
                  platform_id: 0,
                  multiplier: 1,
                  limits: {},
                  features: [],
                  filters: [],
                })
              }
            >
              + Add Platform
            </Button>
          </div>

          {platformsError && (
            <p className="text-sm text-destructive mb-4">{platformsError}</p>
          )}

          {fields.map((item, index) => (
            <div
              key={item.id}
              className="border rounded-lg p-4 mb-5 bg-muted/30 space-y-4"
            >
              <div className="flex justify-between items-center">
                <h4 className="font-medium">Platform #{index + 1}</h4>
                <Button
                  type="button"
                  variant="destructive"
                  onClick={() => remove(index)}
                >
                  Remove
                </Button>
              </div>

              <div className="grid grid-cols-2 gap-4">
                <FormField
                  control={form.control}
                  name={`platforms.${index}.platform_id`}
                  render={({ field }) => {
                    const selectedIds = form
                      .getValues('platforms')
                      ?.map((p) => p.platform_id)
                      ?.filter((id) => id !== field.value);

                    const availablePlatforms = platforms.filter(
                      (p) => !selectedIds.includes(p.value),
                    );

                    return (
                      <FormItem>
                        <FormLabel>Platform</FormLabel>
                        <FormControl>
                          <Select
                            value={field.value ? String(field.value) : ''}
                            onValueChange={(v) => field.onChange(Number(v))}
                          >
                            <SelectTrigger>
                              <SelectValue placeholder="Select platform" />
                            </SelectTrigger>
                            <SelectContent>
                              {availablePlatforms.map((p) => (
                                <SelectItem
                                  key={p.value}
                                  value={String(p.value)}
                                >
                                  {p.label}
                                </SelectItem>
                              ))}
                            </SelectContent>
                          </Select>
                        </FormControl>
                        <FormMessage />
                      </FormItem>
                    );
                  }}
                />
                <FormField
                  control={form.control}
                  name={`platforms.${index}.multiplier`}
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Multiplier</FormLabel>
                      <FormControl>
                        <Input
                          type="number"
                          step="0.1"
                          value={field.value}
                          onChange={(e) =>
                            field.onChange(Number(e.target.value))
                          }
                        />
                      </FormControl>
                    </FormItem>
                  )}
                />
              </div>

              <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
                <FormField
                  control={form.control}
                  name={`platforms.${index}.limits.influencers`}
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Influencers</FormLabel>
                      <FormControl>
                        <Input
                          type="number"
                          min={0}
                          value={field.value ?? ''}
                          onChange={(e) =>
                            field.onChange(
                              e.target.value === ''
                                ? undefined
                                : Number(e.target.value),
                            )
                          }
                        />
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  )}
                />

                <FormField
                  control={form.control}
                  name={`platforms.${index}.limits.campaigns`}
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Campaigns</FormLabel>
                      <FormControl>
                        <Input
                          type="number"
                          min={0}
                          value={field.value ?? ''}
                          onChange={(e) =>
                            field.onChange(
                              e.target.value === ''
                                ? undefined
                                : Number(e.target.value),
                            )
                          }
                        />
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  )}
                />

                <FormField
                  control={form.control}
                  name={`platforms.${index}.limits.reports`}
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Reports</FormLabel>
                      <FormControl>
                        <Input
                          type="number"
                          min={0}
                          value={field.value ?? ''}
                          onChange={(e) =>
                            field.onChange(
                              e.target.value === ''
                                ? undefined
                                : Number(e.target.value),
                            )
                          }
                        />
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  )}
                />

                <FormField
                  control={form.control}
                  name={`platforms.${index}.limits.tracked_content`}
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Tracked Content</FormLabel>
                      <FormControl>
                        <Input
                          type="number"
                          min={0}
                          value={field.value ?? ''}
                          onChange={(e) =>
                            field.onChange(
                              e.target.value === ''
                                ? undefined
                                : Number(e.target.value),
                            )
                          }
                        />
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  )}
                />
              </div>

              <FormField
                control={form.control}
                name={`platforms.${index}.features`}
                render={({ field }) => {
                  const features =
                    (field.value as {
                      feature_key: string;
                      is_enabled: boolean;
                    }[]) ?? [];

                  const reportsIndex = features.findIndex(
                    (f) => f.feature_key === 'reports',
                  );
                  const reportsEnabled =
                    (reportsIndex !== -1 &&
                      features[reportsIndex]?.is_enabled) ||
                    false;

                  const handleToggle = (checked: boolean) => {
                    const next = [...features];
                    if (reportsIndex === -1) {
                      next.push({
                        feature_key: 'reports',
                        is_enabled: checked,
                      });
                    } else {
                      next[reportsIndex] = {
                        ...next[reportsIndex],
                        is_enabled: checked,
                      };
                    }
                    field.onChange(next);
                  };

                  return (
                    <FormItem>
                      <FormLabel>Reports Feature</FormLabel>
                      <FormControl>
                        <div className="flex items-center gap-3">
                          <Switch
                            checked={reportsEnabled}
                            onCheckedChange={handleToggle}
                          />
                          <span className="text-sm">
                            {reportsEnabled ? 'Enabled' : 'Disabled'}
                          </span>
                        </div>
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  );
                }}
              />

              <FormField
                control={form.control}
                name={`platforms.${index}.filters`}
                render={({ field }) => {
                  const platformKey =
                    platformNames[form.watch(`platforms.${index}.platform_id`)];
                  const platformConfig = platformKey
                    ? platformFilters[platformKey]
                    : null;
                  const allFilters = platformConfig && [
                    ...(platformConfig.influencer || []),
                    ...(platformConfig.audience || []),
                    ...(platformConfig.performance || []),
                  ];

                  const currentFilters =
                    (field.value as {
                      filter_key: string;
                      is_enabled: boolean;
                    }[]) ?? [];

                  // تحديث حالة أي فلتر عند الضغط على الـ switch
                  const toggleFilter = (key: string, enabled: boolean) => {
                    const next = [...currentFilters];
                    const existingIndex = next.findIndex(
                      (f) => f.filter_key === key,
                    );

                    if (existingIndex >= 0) {
                      next[existingIndex] = {
                        ...next[existingIndex],
                        is_enabled: enabled,
                      };
                    } else {
                      next.push({ filter_key: key, is_enabled: enabled });
                    }

                    field.onChange(next);
                  };

                  if (!platformConfig) {
                    return (
                      <FormItem>
                        <FormLabel>Filters</FormLabel>
                        <p className="text-sm text-muted-foreground">
                          Select a platform first
                        </p>
                      </FormItem>
                    );
                  }

                  return (
                    <FormItem>
                      <FormLabel>Filters</FormLabel>
                      <div className="border rounded-lg p-3 bg-muted/30 space-y-3 max-h-64 overflow-auto">
                        {allFilters?.map((filter, i) => {
                          const current =
                            currentFilters.find(
                              (f) => f.filter_key === filter.label,
                            )?.is_enabled ?? false;

                          return (
                            <div key={i}>
                              <div className="flex justify-between items-center">
                                <span className="text-sm">
                                  {formatFilterLabel(filter.label)}
                                </span>
                                <Switch
                                  checked={current}
                                  onCheckedChange={(checked) =>
                                    toggleFilter(filter.label, checked)
                                  }
                                />
                              </div>
                              {i < (allFilters?.length ?? 0) - 1 && (
                                <Separator className="my-1" />
                              )}
                            </div>
                          );
                        })}
                      </div>
                      <FormMessage />
                    </FormItem>
                  );
                }}
              />
            </div>
          ))}

          <div className="flex justify-end mt-6">
            <Button
              type="button"
              variant="outline"
              className="mx-3"
              onClick={() => router.push('/packages')}
            >
              Cancel
            </Button>
            <Button type="submit" disabled={isProcessing}>
              {isProcessing && <Spinner className="animate-spin" />}
              {id ? 'Update' : 'Add'}
            </Button>
          </div>
        </form>
      </Form>
    </div>
  );
};

export default PackageAdd;
