'use client';

import { useState, useEffect } from 'react';
import {
  Box,
  Typography,
  Button,
  Paper,
  TextField,
  FormControl,
  InputLabel,
  Select,
  MenuItem,
  IconButton,
  Alert,
  Tabs,
  Tab,
  CircularProgress,
  Card,
  CardContent,
  Divider,
  Dialog,
  DialogTitle,
  DialogContent,
  DialogContentText,
  DialogActions,
  Chip,
  Snackbar,
} from '@mui/material';
import {
  ArrowBack,
  PlayArrow,
  Stop,
  Refresh,
  Save,
  Restaurant,
  LocalCafe,
  Fastfood,
  Delete,
  Edit,
  ChildCare,
  Add,
} from '@mui/icons-material';
import { useRouter } from 'next/navigation';
import { AppShell } from '@/components/layouts/AppShell/AppShell';
import { ProtectedRoute } from '@/components/common/ProtectedRoute';
import { withErrorBoundary } from '@/components/common/ErrorFallbacks';
import { useAuth } from '@/lib/auth/AuthContext';
import { trackingApi, Activity } from '@/lib/api/tracking';
import { childrenApi, Child } from '@/lib/api/children';
import { VoiceInputButton } from '@/components/voice/VoiceInputButton';
import { motion } from 'framer-motion';
import { formatDistanceToNow } from 'date-fns';

interface FeedingData {
  feedingType: 'breast' | 'bottle' | 'solid';
  side?: 'left' | 'right' | 'both';
  duration?: number;
  amount?: number;
  bottleType?: 'formula' | 'breastmilk' | 'other';
  foodDescription?: string;
  amountDescription?: string;
}

function FeedingTrackPage() {
  const router = useRouter();
  const { user } = useAuth();
  const [children, setChildren] = useState<Child[]>([]);
  const [selectedChild, setSelectedChild] = useState<string>('');
  const [feedingType, setFeedingType] = useState<'breast' | 'bottle' | 'solid'>('breast');

  // Breastfeeding state
  const [side, setSide] = useState<'left' | 'right' | 'both'>('left');
  const [duration, setDuration] = useState<number>(0);
  const [isTimerRunning, setIsTimerRunning] = useState(false);
  const [timerSeconds, setTimerSeconds] = useState(0);

  // Bottle feeding state
  const [amount, setAmount] = useState<string>('');
  const [bottleType, setBottleType] = useState<'formula' | 'breastmilk' | 'other'>('formula');

  // Solid food state
  const [foodDescription, setFoodDescription] = useState<string>('');
  const [amountDescription, setAmountDescription] = useState<string>('');

  // Common state
  const [notes, setNotes] = useState<string>('');
  const [recentFeedings, setRecentFeedings] = useState<Activity[]>([]);
  const [loading, setLoading] = useState(false);
  const [childrenLoading, setChildrenLoading] = useState(true);
  const [feedingsLoading, setFeedingsLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [successMessage, setSuccessMessage] = useState<string | null>(null);

  // Delete confirmation dialog
  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
  const [activityToDelete, setActivityToDelete] = useState<string | null>(null);

  const familyId = user?.families?.[0]?.familyId;

  // Load children
  useEffect(() => {
    if (familyId) {
      loadChildren();
    }
  }, [familyId]);

  // Load recent feedings when child is selected
  useEffect(() => {
    if (selectedChild) {
      loadRecentFeedings();
    }
  }, [selectedChild]);

  // Timer effect
  useEffect(() => {
    let interval: NodeJS.Timeout;
    if (isTimerRunning) {
      interval = setInterval(() => {
        setTimerSeconds((prev) => prev + 1);
      }, 1000);
    }
    return () => clearInterval(interval);
  }, [isTimerRunning]);

  const loadChildren = async () => {
    if (!familyId) return;

    try {
      setChildrenLoading(true);
      const childrenData = await childrenApi.getChildren(familyId);
      setChildren(childrenData);
      if (childrenData.length > 0) {
        setSelectedChild(childrenData[0].id);
      }
    } catch (err: any) {
      console.error('Failed to load children:', err);
      setError(err.response?.data?.message || 'Failed to load children');
    } finally {
      setChildrenLoading(false);
    }
  };

  const loadRecentFeedings = async () => {
    if (!selectedChild) return;

    try {
      setFeedingsLoading(true);
      const activities = await trackingApi.getActivities(selectedChild, 'feeding');
      // Sort by timestamp descending and take last 10
      const sorted = activities.sort((a, b) =>
        new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
      ).slice(0, 10);
      setRecentFeedings(sorted);
    } catch (err: any) {
      console.error('Failed to load recent feedings:', err);
    } finally {
      setFeedingsLoading(false);
    }
  };

  const formatDuration = (seconds: number) => {
    const mins = Math.floor(seconds / 60);
    const secs = seconds % 60;
    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
  };

  const startTimer = () => {
    setIsTimerRunning(true);
  };

  const stopTimer = () => {
    setIsTimerRunning(false);
    setDuration(Math.floor(timerSeconds / 60));
  };

  const resetTimer = () => {
    setIsTimerRunning(false);
    setTimerSeconds(0);
    setDuration(0);
  };

  const handleSubmit = async () => {
    if (!selectedChild) {
      setError('Please select a child');
      return;
    }

    // Validation
    if (feedingType === 'breast' && duration === 0 && timerSeconds === 0) {
      setError('Please enter duration or use the timer');
      return;
    }

    if (feedingType === 'bottle' && !amount) {
      setError('Please enter amount');
      return;
    }

    if (feedingType === 'solid' && !foodDescription) {
      setError('Please enter food description');
      return;
    }

    try {
      setLoading(true);
      setError(null);

      const data: FeedingData = {
        feedingType,
      };

      if (feedingType === 'breast') {
        data.side = side;
        data.duration = duration || Math.floor(timerSeconds / 60);
      } else if (feedingType === 'bottle') {
        data.amount = parseFloat(amount);
        data.bottleType = bottleType;
      } else if (feedingType === 'solid') {
        data.foodDescription = foodDescription;
        data.amountDescription = amountDescription;
      }

      await trackingApi.createActivity(selectedChild, {
        type: 'feeding',
        timestamp: new Date().toISOString(),
        data,
        notes: notes || undefined,
      });

      setSuccessMessage('Feeding logged successfully!');

      // Reset form
      resetForm();

      // Reload recent feedings
      await loadRecentFeedings();
    } catch (err: any) {
      console.error('Failed to save feeding:', err);
      setError(err.response?.data?.message || 'Failed to save feeding');
    } finally {
      setLoading(false);
    }
  };

  const resetForm = () => {
    setSide('left');
    setDuration(0);
    setTimerSeconds(0);
    setIsTimerRunning(false);
    setAmount('');
    setBottleType('formula');
    setFoodDescription('');
    setAmountDescription('');
    setNotes('');
  };

  const handleDeleteClick = (activityId: string) => {
    setActivityToDelete(activityId);
    setDeleteDialogOpen(true);
  };

  const handleDeleteConfirm = async () => {
    if (!activityToDelete) return;

    try {
      setLoading(true);
      await trackingApi.deleteActivity(activityToDelete);
      setSuccessMessage('Feeding deleted successfully');
      setDeleteDialogOpen(false);
      setActivityToDelete(null);
      await loadRecentFeedings();
    } catch (err: any) {
      console.error('Failed to delete feeding:', err);
      setError(err.response?.data?.message || 'Failed to delete feeding');
    } finally {
      setLoading(false);
    }
  };

  const getFeedingTypeIcon = (type: string) => {
    switch (type) {
      case 'breast':
        return <LocalCafe />;
      case 'bottle':
        return <Restaurant />;
      case 'solid':
        return <Fastfood />;
      default:
        return <Restaurant />;
    }
  };

  const getFeedingDetails = (activity: Activity) => {
    const data = activity.data as FeedingData;

    if (data.feedingType === 'breast') {
      return `${data.side?.toUpperCase()} - ${data.duration || 0} min`;
    } else if (data.feedingType === 'bottle') {
      return `${data.amount || 0} ml - ${data.bottleType}`;
    } else if (data.feedingType === 'solid') {
      return `${data.foodDescription}${data.amountDescription ? ` - ${data.amountDescription}` : ''}`;
    }
    return '';
  };

  if (childrenLoading) {
    return (
      <ProtectedRoute>
        <AppShell>
          <Box sx={{ display: 'flex', justifyContent: 'center', py: 8 }}>
            <CircularProgress />
          </Box>
        </AppShell>
      </ProtectedRoute>
    );
  }

  if (!familyId || children.length === 0) {
    return (
      <ProtectedRoute>
        <AppShell>
          <Card>
            <CardContent sx={{ textAlign: 'center', py: 8 }}>
              <ChildCare sx={{ fontSize: 64, color: 'text.secondary', mb: 2 }} />
              <Typography variant="h6" color="text.secondary" gutterBottom>
                No Children Added
              </Typography>
              <Typography variant="body2" color="text.secondary" sx={{ mb: 3 }}>
                You need to add a child before you can track feeding activities
              </Typography>
              <Button
                variant="contained"
                startIcon={<Add />}
                onClick={() => router.push('/children')}
              >
                Add Child
              </Button>
            </CardContent>
          </Card>
        </AppShell>
      </ProtectedRoute>
    );
  }

  return (
    <ProtectedRoute>
      <AppShell>
        <Box>
          <Box sx={{ display: 'flex', alignItems: 'center', mb: 3 }}>
            <IconButton onClick={() => router.back()} sx={{ mr: 2 }}>
              <ArrowBack />
            </IconButton>
            <Typography variant="h4" fontWeight="600" sx={{ flex: 1 }}>
              Track Feeding
            </Typography>
            <VoiceInputButton
              onTranscript={(transcript) => {
                console.log('[Feeding] Voice transcript:', transcript);
              }}
              onClassifiedIntent={(result) => {
                if (result.intent === 'feeding' && result.structuredData) {
                  const data = result.structuredData;
                  // Auto-fill form with voice data
                  if (data.type === 'bottle' && data.amount) {
                    setFeedingType('bottle');
                    setAmount(data.amount.toString());
                  } else if (data.type?.includes('breast')) {
                    setFeedingType('breast');
                    if (data.side) setSide(data.side);
                    if (data.duration) setDuration(data.duration.toString());
                  } else if (data.type === 'solid') {
                    setFeedingType('solid');
                  }
                }
              }}
              size="medium"
            />
          </Box>

          {error && (
            <Alert severity="error" sx={{ mb: 3 }} onClose={() => setError(null)}>
              {error}
            </Alert>
          )}

          <motion.div
            initial={{ opacity: 0, y: 20 }}
            animate={{ opacity: 1, y: 0 }}
            transition={{ duration: 0.3 }}
          >
            {/* Child Selector */}
            {children.length > 1 && (
              <Paper sx={{ p: 2, mb: 3 }}>
                <FormControl fullWidth>
                  <InputLabel>Select Child</InputLabel>
                  <Select
                    value={selectedChild}
                    onChange={(e) => setSelectedChild(e.target.value)}
                    label="Select Child"
                  >
                    {children.map((child) => (
                      <MenuItem key={child.id} value={child.id}>
                        {child.name}
                      </MenuItem>
                    ))}
                  </Select>
                </FormControl>
              </Paper>
            )}

            {/* Main Form */}
            <Paper sx={{ p: 3, mb: 3 }}>
              {/* Feeding Type Tabs */}
              <Tabs
                value={feedingType}
                onChange={(_, newValue) => setFeedingType(newValue)}
                sx={{ mb: 3 }}
                variant="fullWidth"
              >
                <Tab label="Breastfeeding" value="breast" icon={<LocalCafe />} iconPosition="start" />
                <Tab label="Bottle" value="bottle" icon={<Restaurant />} iconPosition="start" />
                <Tab label="Solid Food" value="solid" icon={<Fastfood />} iconPosition="start" />
              </Tabs>

              {/* Breastfeeding Form */}
              {feedingType === 'breast' && (
                <Box>
                  {/* Timer Display */}
                  <Box sx={{ textAlign: 'center', mb: 4 }}>
                    <Typography variant="h2" fontWeight="600" sx={{ mb: 2 }}>
                      {formatDuration(timerSeconds)}
                    </Typography>
                    <Box sx={{ display: 'flex', gap: 2, justifyContent: 'center' }}>
                      {!isTimerRunning ? (
                        <Button
                          variant="contained"
                          size="large"
                          startIcon={<PlayArrow />}
                          onClick={startTimer}
                        >
                          Start Timer
                        </Button>
                      ) : (
                        <Button
                          variant="contained"
                          color="error"
                          size="large"
                          startIcon={<Stop />}
                          onClick={stopTimer}
                        >
                          Stop Timer
                        </Button>
                      )}
                      <Button
                        variant="outlined"
                        size="large"
                        startIcon={<Refresh />}
                        onClick={resetTimer}
                      >
                        Reset
                      </Button>
                    </Box>
                  </Box>

                  {/* Side Selector */}
                  <FormControl fullWidth sx={{ mb: 3 }}>
                    <InputLabel>Side</InputLabel>
                    <Select
                      value={side}
                      onChange={(e) => setSide(e.target.value as 'left' | 'right' | 'both')}
                      label="Side"
                    >
                      <MenuItem value="left">Left</MenuItem>
                      <MenuItem value="right">Right</MenuItem>
                      <MenuItem value="both">Both</MenuItem>
                    </Select>
                  </FormControl>

                  {/* Manual Duration Input */}
                  <TextField
                    fullWidth
                    label="Duration (minutes)"
                    type="number"
                    value={duration || ''}
                    onChange={(e) => setDuration(parseInt(e.target.value) || 0)}
                    sx={{ mb: 3 }}
                    helperText="Or use the timer above"
                  />
                </Box>
              )}

              {/* Bottle Form */}
              {feedingType === 'bottle' && (
                <Box>
                  <TextField
                    fullWidth
                    label="Amount (ml)"
                    type="number"
                    value={amount}
                    onChange={(e) => setAmount(e.target.value)}
                    sx={{ mb: 3 }}
                  />

                  <FormControl fullWidth sx={{ mb: 3 }}>
                    <InputLabel>Type</InputLabel>
                    <Select
                      value={bottleType}
                      onChange={(e) => setBottleType(e.target.value as 'formula' | 'breastmilk' | 'other')}
                      label="Type"
                    >
                      <MenuItem value="formula">Formula</MenuItem>
                      <MenuItem value="breastmilk">Breast Milk</MenuItem>
                      <MenuItem value="other">Other</MenuItem>
                    </Select>
                  </FormControl>
                </Box>
              )}

              {/* Solid Food Form */}
              {feedingType === 'solid' && (
                <Box>
                  <TextField
                    fullWidth
                    label="Food Description"
                    value={foodDescription}
                    onChange={(e) => setFoodDescription(e.target.value)}
                    sx={{ mb: 3 }}
                    placeholder="e.g., Mashed banana, Rice cereal"
                  />

                  <TextField
                    fullWidth
                    label="Amount (optional)"
                    value={amountDescription}
                    onChange={(e) => setAmountDescription(e.target.value)}
                    sx={{ mb: 3 }}
                    placeholder="e.g., 2 tablespoons, Half bowl"
                  />
                </Box>
              )}

              {/* Common Notes Field */}
              <TextField
                fullWidth
                label="Notes (optional)"
                multiline
                rows={3}
                value={notes}
                onChange={(e) => setNotes(e.target.value)}
                sx={{ mb: 3 }}
                placeholder="Any additional notes..."
              />

              {/* Submit Button */}
              <Button
                fullWidth
                type="button"
                variant="contained"
                size="large"
                startIcon={<Save />}
                onClick={handleSubmit}
                disabled={loading}
              >
                {loading ? 'Saving...' : 'Save Feeding'}
              </Button>
            </Paper>

            {/* Recent Feedings */}
            <Paper sx={{ p: 3 }}>
              <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2 }}>
                <Typography variant="h6" fontWeight="600">
                  Recent Feedings
                </Typography>
                <IconButton onClick={loadRecentFeedings} disabled={feedingsLoading}>
                  <Refresh />
                </IconButton>
              </Box>

              {feedingsLoading ? (
                <Box sx={{ display: 'flex', justifyContent: 'center', py: 4 }}>
                  <CircularProgress size={30} />
                </Box>
              ) : recentFeedings.length === 0 ? (
                <Box sx={{ textAlign: 'center', py: 4 }}>
                  <Typography variant="body2" color="text.secondary">
                    No feeding activities yet
                  </Typography>
                </Box>
              ) : (
                <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
                  {recentFeedings.map((activity, index) => {
                    const data = activity.data as FeedingData;
                    return (
                      <motion.div
                        key={activity.id}
                        initial={{ opacity: 0, y: 10 }}
                        animate={{ opacity: 1, y: 0 }}
                        transition={{ duration: 0.2, delay: index * 0.05 }}
                      >
                        <Card variant="outlined">
                          <CardContent>
                            <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 2 }}>
                              <Box sx={{ mt: 0.5 }}>
                                {getFeedingTypeIcon(data.feedingType)}
                              </Box>
                              <Box sx={{ flex: 1 }}>
                                <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
                                  <Typography variant="body1" fontWeight="600">
                                    {data.feedingType.charAt(0).toUpperCase() + data.feedingType.slice(1)}
                                  </Typography>
                                  <Chip
                                    label={formatDistanceToNow(new Date(activity.timestamp), { addSuffix: true })}
                                    size="small"
                                    variant="outlined"
                                  />
                                </Box>
                                <Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
                                  {getFeedingDetails(activity)}
                                </Typography>
                                {activity.notes && (
                                  <Typography variant="body2" color="text.secondary" sx={{ fontStyle: 'italic' }}>
                                    {activity.notes}
                                  </Typography>
                                )}
                              </Box>
                              <Box sx={{ display: 'flex', gap: 0.5 }}>
                                <IconButton
                                  size="small"
                                  color="error"
                                  onClick={() => handleDeleteClick(activity.id)}
                                  disabled={loading}
                                >
                                  <Delete />
                                </IconButton>
                              </Box>
                            </Box>
                          </CardContent>
                        </Card>
                      </motion.div>
                    );
                  })}
                </Box>
              )}
            </Paper>
          </motion.div>
        </Box>

        {/* Delete Confirmation Dialog */}
        <Dialog
          open={deleteDialogOpen}
          onClose={() => setDeleteDialogOpen(false)}
        >
          <DialogTitle>Delete Feeding Activity?</DialogTitle>
          <DialogContent>
            <DialogContentText>
              Are you sure you want to delete this feeding activity? This action cannot be undone.
            </DialogContentText>
          </DialogContent>
          <DialogActions>
            <Button onClick={() => setDeleteDialogOpen(false)} disabled={loading}>
              Cancel
            </Button>
            <Button onClick={handleDeleteConfirm} color="error" disabled={loading}>
              {loading ? 'Deleting...' : 'Delete'}
            </Button>
          </DialogActions>
        </Dialog>

        {/* Success Snackbar */}
        <Snackbar
          open={!!successMessage}
          autoHideDuration={3000}
          onClose={() => setSuccessMessage(null)}
          message={successMessage}
        />
      </AppShell>
    </ProtectedRoute>
  );
}

export default withErrorBoundary(FeedingTrackPage, 'form');
