import { GoogleCalendarEvent, getUserCalendars as getGoogleCalendars, getUpcomingEvents as getGoogleEvents, initializeOAuth as initializeGoogleOAuth } from './google-calendar';
import { AppleCalendarEvent, getUserCalendars as getAppleCalendars, getUpcomingEvents as getAppleEvents } from './apple-calendar';
import { getUpcomingEvents as getOutlookEvents, refreshAccessToken as refreshOutlookTokenAPI, createEvent as createOutlookEvent, updateEvent as updateOutlookEvent, deleteEvent as deleteOutlookEvent } from './outlook-calendar';
import { getUserCalendars as getSynologyCalendars, getUpcomingEvents as getSynologyEvents } from './synology-calendar';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

export interface CalendarEvent {
  id: string;
  title: string;
  description?: string;
  start: {
    dateTime?: string;
    date?: string;
  };
  end: {
    dateTime?: string;
    date?: string;
  };
  location?: string;
  url?: string;
  recurrence?: string;
  recurringEventId?: string;
  isRecurring?: boolean;
  source: 'google' | 'apple' | 'outlook' | 'synology';
  calendarId: string;
  calendarTitle: string;
  backgroundColor?: string;
  allDay?: boolean;
}

/**
 * Convert friendly recurrence name to RRULE string
 */
function toRRule(recurrence?: string): string | null {
  switch (recurrence) {
    case 'daily': return 'RRULE:FREQ=DAILY';
    case 'weekly': return 'RRULE:FREQ=WEEKLY';
    case 'biweekly': return 'RRULE:FREQ=WEEKLY;INTERVAL=2';
    case 'monthly': return 'RRULE:FREQ=MONTHLY';
    case 'yearly': return 'RRULE:FREQ=YEARLY';
    default: return null;
  }
}

/**
 * Convert friendly recurrence name to Outlook Graph recurrence object
 */
function toOutlookRecurrence(recurrence?: string, startDate?: Date): any {
  if (!recurrence || recurrence === 'none') return undefined;
  const start = startDate || new Date();
  const range = {
    type: 'noEnd',
    startDate: start.toISOString().split('T')[0],
  };
  switch (recurrence) {
    case 'daily':
      return { pattern: { type: 'daily', interval: 1 }, range };
    case 'weekly':
      return { pattern: { type: 'weekly', interval: 1, daysOfWeek: [['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'][start.getDay()]] }, range };
    case 'biweekly':
      return { pattern: { type: 'weekly', interval: 2, daysOfWeek: [['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'][start.getDay()]] }, range };
    case 'monthly':
      return { pattern: { type: 'absoluteMonthly', interval: 1, dayOfMonth: start.getDate() }, range };
    case 'yearly':
      return { pattern: { type: 'absoluteYearly', interval: 1, dayOfMonth: start.getDate(), month: start.getMonth() + 1 }, range };
    default: return undefined;
  }
}

// Google Calendar event color mapping (colorId -> hex color)
const GOOGLE_EVENT_COLORS: Record<string, string> = {
  '1': '#7986cb', // Lavender
  '2': '#33b679', // Sage
  '3': '#8e24aa', // Grape
  '4': '#e67c73', // Flamingo
  '5': '#f6bf26', // Banana
  '6': '#f4511e', // Tangerine
  '7': '#039be5', // Peacock
  '8': '#616161', // Graphite
  '9': '#3f51b5', // Blueberry
  '10': '#0b8043', // Basil
  '11': '#d50000', // Tomato
};

function getGoogleEventColor(colorId: string): string {
  return GOOGLE_EVENT_COLORS[colorId] || '#039be5'; // Default to Peacock
}

export interface CalendarConnection {
  id: string;
  provider: 'google' | 'apple' | 'outlook' | 'synology';
  accessToken: string;
  refreshToken?: string;
  expiresAt?: Date;
  calendars?: Array<{
    id: string;
    title: string;
    isPrimary?: boolean;
    selected?: boolean;
    backgroundColor?: string;
  }> | any; // Type it loosely for JSON compatibility
}

/**
 * Refresh the Google access token using the refresh token
 */
async function refreshGoogleToken(connection: CalendarConnection): Promise<string | null> {
  if (!connection.refreshToken) {
    console.log('[CALENDAR] No refresh token available for connection:', connection.id);
    return null;
  }

  try {
    const oauth2Client = initializeGoogleOAuth(
      process.env.GOOGLE_CLIENT_ID || '',
      process.env.GOOGLE_CLIENT_SECRET || '',
      process.env.GOOGLE_REDIRECT_URI || ''
    );

    oauth2Client.setCredentials({
      refresh_token: connection.refreshToken
    });

    console.log('[CALENDAR] Refreshing Google access token...');
    const { credentials } = await oauth2Client.refreshAccessToken();

    if (credentials.access_token) {
      // Update the token in the database
      await prisma.calendarConnection.update({
        where: { id: connection.id },
        data: {
          accessToken: credentials.access_token,
          expiresAt: credentials.expiry_date ? new Date(credentials.expiry_date) : null
        }
      });
      console.log('[CALENDAR] Token refreshed successfully');
      return credentials.access_token;
    }
  } catch (error) {
    console.error('[CALENDAR] Failed to refresh token:', error);
  }
  return null;
}

/**
 * Refresh the Outlook access token using the refresh token
 */
async function refreshOutlookToken(connection: CalendarConnection): Promise<string | null> {
  if (!connection.refreshToken) {
    console.log('[CALENDAR] No refresh token available for connection:', connection.id);
    return null;
  }

  try {
    console.log('[CALENDAR] Refreshing Outlook access token...');
    const data = await refreshOutlookTokenAPI(connection.refreshToken);

    if (data.access_token) {
      // Update the token in the database
      const expiresAt = new Date();
      expiresAt.setSeconds(expiresAt.getSeconds() + data.expires_in);

      await prisma.calendarConnection.update({
        where: { id: connection.id },
        data: {
          accessToken: data.access_token,
          refreshToken: data.refresh_token || connection.refreshToken, // Update refresh token if provided
          expiresAt
        }
      });
      console.log('[CALENDAR] Outlook token refreshed successfully');
      return data.access_token;
    }
  } catch (error) {
    console.error('[CALENDAR] Failed to refresh Outlook token:', error);
  }
  return null;
}

/**
 * Check if the token is expired or about to expire
 */
function isTokenExpired(expiresAt?: Date): boolean {
  if (!expiresAt) return true; // Assume expired if no expiry info

  // Consider token expired if it expires within the next 5 minutes
  const bufferMs = 5 * 60 * 1000;
  return new Date().getTime() > (new Date(expiresAt).getTime() - bufferMs);
}

/**
 * Fetch calendar events from connected accounts
 */
export const getCalendarEvents = async (
  connections: CalendarConnection[],
  timeMin: string,
  timeMax: string
): Promise<CalendarEvent[]> => {
  const allEvents: CalendarEvent[] = [];

  console.log('[CALENDAR] Fetching events from', connections.length, 'connections');
  console.log('[CALENDAR] Date range:', timeMin, 'to', timeMax);

  for (const connection of connections) {
    try {
      let events: any[] = [];
      let accessToken = connection.accessToken;

      if (connection.provider === 'google') {
        console.log('[CALENDAR] Processing Google connection:', connection.id);

        // Check if token is expired and refresh if needed
        if (isTokenExpired(connection.expiresAt)) {
          console.log('[CALENDAR] Token expired, attempting refresh...');
          const newToken = await refreshGoogleToken(connection);
          if (newToken) {
            accessToken = newToken;
          } else {
            console.error('[CALENDAR] Failed to refresh token, skipping connection');
            continue;
          }
        }

        // Initialize OAuth client
        const oauth2Client = initializeGoogleOAuth(
          process.env.GOOGLE_CLIENT_ID || '',
          process.env.GOOGLE_CLIENT_SECRET || '',
          process.env.GOOGLE_REDIRECT_URI || ''
        );

        // Identify which calendars to fetch events from
        let calendarIds: string[] = [];
        let calendars: any[] = [];

        // Use stored calendars if available and filtered by selection
        if (connection.calendars && Array.isArray(connection.calendars)) {
          // We have stored preferences - but check if they have backgroundColor
          const storedCalendars = connection.calendars as any[];
          const hasMissingColors = storedCalendars.some((c: any) => !c.backgroundColor);

          if (hasMissingColors) {
            // Refresh from API to get colors
            console.log('[CALENDAR] Stored calendars missing backgroundColor, refreshing from API...');
            const freshCalendars = await getGoogleCalendars(oauth2Client, accessToken);
            // Merge fresh data with stored selection preferences
            calendars = storedCalendars.map((stored: any) => {
              const fresh = freshCalendars.find(f => f.id === stored.id);
              return {
                ...stored,
                backgroundColor: fresh?.backgroundColor || stored.backgroundColor,
                summary: fresh?.summary || stored.title // Ensure summary is available
              };
            });
            console.log('[CALENDAR] Refreshed calendars with colors:', calendars.map(c => ({ id: c.id, bg: c.backgroundColor })));
          } else {
            calendars = storedCalendars;
          }

          calendarIds = calendars
            .filter((c: any) => c.selected !== false) // Include unless explicitly false
            .map((c: any) => c.id);
          console.log('[CALENDAR] Using calendars, selected:', calendarIds.length, 'of', calendars.length);
        } else {
          // Fallback: fetch all if no stored list (legacy behavior)
          console.log('[CALENDAR] No stored calendars, fetching from API...');
          calendars = await getGoogleCalendars(oauth2Client, accessToken);
          calendarIds = calendars.map(c => c.id);
          console.log('[CALENDAR] Fetched', calendars.length, 'calendars from API');
        }

        if (calendarIds.length === 0) {
          console.log('[CALENDAR] No calendars selected, skipping');
          continue;
        }

        // Fetch events for each calendar
        console.log('[CALENDAR] Fetching events from', calendarIds.length, 'calendars...');
        for (const calendarId of calendarIds) {
          try {
            console.log('[CALENDAR] Fetching events from calendar:', calendarId);
            const calendarEvents = await getGoogleEvents(
              oauth2Client,
              accessToken,
              calendarId,
              timeMin,
              timeMax
            );

            console.log('[CALENDAR] Found', calendarEvents.length, 'events in calendar:', calendarId);

            // Get calendar data for color fallback
            const calendarData = calendars.find(c => c.id === calendarId);

            events = events.concat(calendarEvents.map((event: any) => {
              const eventColor = event.colorId ? getGoogleEventColor(event.colorId) : calendarData?.backgroundColor;
              return {
                id: event.id,
                title: event.summary || '(No Title)', // Map summary to title
                description: event.description,
                start: event.start,
                end: event.end,
                location: event.location,
                source: 'google' as const,
                calendarId,
                calendarTitle: calendarData?.summary || calendarData?.title || 'Google Calendar',
                backgroundColor: eventColor
              };
            }));
          } catch (calError) {
            console.error(`[CALENDAR] Error fetching events from calendar ${calendarId}:`, calError);
            // Continue with other calendars
          }
        }
      } else if (connection.provider === 'apple') {
        const [email, appPassword] = connection.accessToken.split(':');

        if (!email || !appPassword) {
          console.error('[CALENDAR] Invalid Apple credentials format');
          continue;
        }

        // Get user calendars to identify which ones to fetch events from
        // We can pass null/dummy client if getUserCalendars just calls validateCredentials which creates its own client
        // Actually getUserCalendars in apple-calendar.ts (wrapper around validateCredentials) takes (email, password)
        // But here it was imported as getAppleCalendars(appleClient, accessToken) which matched the old signature?

        // Let's check apple-calendar.ts signature for getUserCalendars.
        // It is: export const getUserCalendars = validateCredentials;
        // validateCredentials: (email: string, appSpecificPassword: string)

        const calendars = await getAppleCalendars(email, appPassword);
        const calendarIds = calendars.map(c => c.id);

        // Fetch events for each calendar
        for (const calendarId of calendarIds) {
          const calendarEvents = await getAppleEvents(
            email,
            appPassword,
            calendarId,
            timeMin,
            timeMax
          );

          console.log(`[CALENDAR] Fetched ${calendarEvents.length} events from calendar ${calendarId}`);

          events = events.concat(calendarEvents.map((event: any) => {
            // Date-only strings (YYYY-MM-DD) indicate all-day events
            const isDateOnly = (s: string) => s && !s.includes('T');
            const startIsAllDay = isDateOnly(event.startDate);
            return {
              id: event.id,
              title: event.title,
              description: event.description,
              start: {
                dateTime: startIsAllDay ? undefined : event.startDate,
                date: startIsAllDay ? event.startDate : undefined,
              },
              end: {
                dateTime: startIsAllDay ? undefined : event.endDate,
                date: startIsAllDay ? event.endDate : undefined,
              },
              location: event.location,
              url: event.url,
              recurringEventId: event.recurringEventId,
              isRecurring: event.isRecurring,
              source: 'apple' as const,
              calendarId,
              calendarTitle: calendars.find(c => c.id === calendarId)?.title || 'Apple Calendar',
              backgroundColor: calendars.find(c => c.id === calendarId)?.color || '#FF3B30'
            };
          }));
        }
      } else if (connection.provider === 'synology') {
        const [username, password] = connection.accessToken.split(':');
        const serverUrl = connection.refreshToken;

        if (!username || !password || !serverUrl) {
          console.error('[CALENDAR] Invalid Synology credentials format');
          continue;
        }

        // Use stored calendar selection (same pattern as Outlook/Google)
        let calendarIds: string[] = [];
        let calendars: any[] = [];

        if (connection.calendars && Array.isArray(connection.calendars) && connection.calendars.length > 0) {
          calendars = connection.calendars as any[];
          calendarIds = calendars
            .filter((c: any) => c.selected !== false)
            .map((c: any) => c.id);
          console.log('[CALENDAR] Synology: using stored calendars, selected:', calendarIds.length, 'of', calendars.length);
        } else {
          // Fallback: fetch fresh from server if no stored calendars
          console.log('[CALENDAR] Synology: no stored calendars, fetching from server...');
          const fresh = await getSynologyCalendars(serverUrl, username, password);
          calendars = fresh;
          calendarIds = fresh.map(c => c.id);
        }

        if (calendarIds.length === 0) {
          console.log('[CALENDAR] Synology: no calendars selected, skipping');
          continue;
        }

        for (const calendarId of calendarIds) {
          try {
            const calendarEvents = await getSynologyEvents(
              serverUrl,
              username,
              password,
              calendarId,
              timeMin,
              timeMax
            );

            console.log(`[CALENDAR] Synology: fetched ${calendarEvents.length} events from calendar ${calendarId}`);
            const calendarData = calendars.find(c => c.id === calendarId);

            events = events.concat(calendarEvents.map((event: any) => {
              const isDateOnly = (s: string) => s && !s.includes('T');
              const startIsAllDay = isDateOnly(event.startDate);
              return {
                id: event.id,
                title: event.title,
                description: event.description,
                start: {
                  dateTime: startIsAllDay ? undefined : event.startDate,
                  date: startIsAllDay ? event.startDate : undefined,
                },
                end: {
                  dateTime: startIsAllDay ? undefined : event.endDate,
                  date: startIsAllDay ? event.endDate : undefined,
                },
                location: event.location,
                url: event.url,
                recurringEventId: event.recurringEventId,
                isRecurring: event.isRecurring,
                source: 'synology' as const,
                calendarId,
                calendarTitle: calendarData?.title || 'Synology Calendar',
                backgroundColor: calendarData?.color || '#1b85ff'
              };
            }));
          } catch (calError) {
            console.error(`[CALENDAR] Synology: error fetching events from calendar ${calendarId}:`, calError);
          }
        }
      } else if (connection.provider === 'outlook') {
        console.log('[CALENDAR] Processing Outlook connection:', connection.id);

        if (isTokenExpired(connection.expiresAt)) {
          console.log('[CALENDAR] Outlook token expired, attempting refresh...');
          const newToken = await refreshOutlookToken(connection);
          if (newToken) {
            accessToken = newToken;
          } else {
            console.error('[CALENDAR] Failed to refresh Outlook token, skipping connection');
            continue;
          }
        }

        // Get calendars to fetch
        let calendarIds: string[] = [];
        let calendars: any[] = [];

        if (connection.calendars && Array.isArray(connection.calendars)) {
          calendars = connection.calendars as any[];
          calendarIds = calendars
            .filter((c: any) => c.selected !== false)
            .map((c: any) => c.id);
        }

        if (calendarIds.length > 0) {
          console.log('[CALENDAR] Fetching Outlook events from', calendarIds.length, 'calendars');
          for (const calendarId of calendarIds) {
            try {
              const outlookEvents = await getOutlookEvents(
                accessToken,
                calendarId,
                timeMin,
                timeMax
              );

              const calendarData = calendars.find(c => c.id === calendarId);

              events = events.concat(outlookEvents.map((event: any) => ({
                id: event.id,
                title: event.summary || '(No Title)',
                description: event.description,
                start: event.start,
                end: event.end,
                location: event.location || '',
                source: 'outlook' as const,
                calendarId,
                calendarTitle: calendarData?.title || 'Outlook Calendar',
                backgroundColor: '#0078d4' // Outlook Blue
              })));

            } catch (calError) {
              console.error(`[CALENDAR] Error fetching Outlook events from ${calendarId}:`, calError);
            }
          }
        }
      }

      console.log('[CALENDAR] Total events for connection:', events.length);
      allEvents.push(...events);
    } catch (error) {
      console.error(`[CALENDAR] Error fetching events from ${connection.provider} calendar:`, error);
      // Continue with other connections even if one fails
    }
  }

  console.log('[CALENDAR] Total events from all connections:', allEvents.length);
  return allEvents;
};

/**
 * Format event for display in the weekly view
 */
export const formatEventForDisplay = (event: CalendarEvent): CalendarEvent => {
  // Ensure consistent structure for display
  return {
    id: event.id,
    title: event.title,
    description: event.description,
    start: {
      dateTime: event.start.dateTime,
      date: event.start.date,
    },
    end: {
      dateTime: event.end.dateTime,
      date: event.end.date,
    },
    location: event.location,
    source: event.source,
    calendarId: event.calendarId,
    calendarTitle: event.calendarTitle,
  };
};

/**
 * Merge calendar events with existing tasks to avoid duplicates
 */
export const mergeWithTasks = (
  events: CalendarEvent[],
  tasks: Array<{ id: string; title: string }>
): CalendarEvent[] => {
  // Simple deduplication logic - if event title matches task title, consider it a duplicate
  const taskTitles = new Set(tasks.map(task => task.title.toLowerCase()));

  return events.filter(event => {
    // Only show events where the title doesn't match an existing task title
    return !taskTitles.has(event.title.toLowerCase());
  });
};

/**
 * Filter events by date range (week view)
 */
export const filterEventsByDateRange = (
  events: CalendarEvent[],
  startOfWeek: Date,
  endOfWeek: Date
): CalendarEvent[] => {
  const startTimestamp = startOfWeek.getTime();
  const endTimestamp = endOfWeek.getTime();

  return events.filter(event => {
    const eventStart = event.start.dateTime ? new Date(event.start.dateTime).getTime() :
      event.start.date ? new Date(event.start.date).getTime() : 0;

    return eventStart >= startTimestamp && eventStart <= endTimestamp;
  });
};

/**
 * Determine event visibility based on user settings
 */
export const determineEventVisibility = (
  event: CalendarEvent,
  userSettings: {
    showGoogleEvents?: boolean;
    showAppleEvents?: boolean;
    showPrivateEvents?: boolean;
  }
): boolean => {
  // Check if the user wants to see events from this provider
  if ((event.source === 'google' && !userSettings.showGoogleEvents) ||
    (event.source === 'apple' && !userSettings.showAppleEvents)) {
    return false;
  }

  // Check if private events should be shown (this is a simplified check)
  // In a real implementation, this would involve checking privacy settings
  if (!userSettings.showPrivateEvents) {
    // Simplified - in practice, private events would be filtered based on actual privacy flags
    return true;
  }

  return true;
};

/**
 * Create a new calendar event
 */
export const createCalendarEvent = async (
  connection: CalendarConnection,
  calendarId: string,
  event: Partial<CalendarEvent>
): Promise<CalendarEvent> => {
  if (connection.provider === 'google') {
    // Check key fields
    if (!event.title) throw new Error('Event title is required');
    if (!event.start || !event.end) throw new Error('Event start and end times are required');

    // Refresh token if needed
    let accessToken = connection.accessToken;
    if (isTokenExpired(connection.expiresAt)) {
      const newToken = await refreshGoogleToken(connection);
      if (newToken) accessToken = newToken;
      else throw new Error('Failed to refresh token');
    }

    const oauth2Client = initializeGoogleOAuth(
      process.env.GOOGLE_CLIENT_ID || '',
      process.env.GOOGLE_CLIENT_SECRET || '',
      process.env.GOOGLE_REDIRECT_URI || ''
    );

    // Map to Google format
    const rrule = toRRule(event.recurrence);
    const googleEvent: any = {
      summary: event.title,
      description: event.description,
      start: event.start,
      end: event.end,
      location: event.location,
      ...(rrule ? { recurrence: [rrule] } : {}),
      ...(event.allDay ? { allDay: true } : {}),
      ...(event.url ? { source: { url: event.url, title: event.url } } : {}),
    };

    const createdEvent = await import('./google-calendar').then(m =>
      m.createEvent(oauth2Client, accessToken, calendarId, googleEvent)
    );

    return {
      id: createdEvent.id,
      title: createdEvent.summary,
      description: createdEvent.description,
      start: createdEvent.start,
      end: createdEvent.end,
      location: createdEvent.location,
      source: 'google',
      calendarId,
      calendarTitle: '', // We don't have this here, simpler to leave empty or fetch
    } as CalendarEvent;
  } else if (connection.provider === 'outlook') {
    if (!event.title) throw new Error('Event title is required');
    if (!event.start || !event.end) throw new Error('Event start and end times are required');

    let accessToken = connection.accessToken;
    if (isTokenExpired(connection.expiresAt)) {
      const newToken = await refreshOutlookToken(connection);
      if (newToken) accessToken = newToken;
      else throw new Error('Failed to refresh token');
    }

    const startDate = event.start?.dateTime ? new Date(event.start.dateTime) : new Date();
    const createdEvent = await createOutlookEvent(accessToken, calendarId, {
      summary: event.title,
      description: event.description,
      start: event.start,
      end: event.end,
      location: event.location,
      allDay: event.allDay,
      recurrence: toOutlookRecurrence(event.recurrence, startDate),
    });

    return {
      id: createdEvent.id,
      title: createdEvent.summary,
      description: createdEvent.description,
      start: createdEvent.start,
      end: createdEvent.end,
      location: createdEvent.location,
      allDay: createdEvent.allDay,
      source: 'outlook',
      calendarId,
      calendarTitle: '',
    } as CalendarEvent;
  } else if (connection.provider === 'apple') {
    const [email, appPassword] = connection.accessToken.split(':');

    // We need to map our event format to what createEvent expects
    // createEvent expects: { title, description?, location?, start: {dateTime?, date?}, end: ... }
    // Our 'event' arg is Partial<CalendarEvent>, which matches well.
    // However, event.start and event.end might be undefined in Partial, so we need checks.

    // Handle all-day event normalization for Apple (requires 'date' property, not 'dateTime')
    // AND exclusive end date (add 1 day if needed)
    const start = { ...event.start! };
    const end = { ...event.end! };

    if (event.allDay) {
      if (start.dateTime && !start.date) {
        start.date = start.dateTime.split('T')[0];
        delete start.dateTime;
      }
      if (end.dateTime && !end.date) {
        end.date = end.dateTime.split('T')[0];
        delete end.dateTime;
      }

      // Apple/iCloud requires DTEND to be the day AFTER the last day of the event
      if (start.date && end.date && start.date === end.date) {
        const d = new Date(end.date);
        d.setDate(d.getDate() + 1);
        end.date = d.toISOString().split('T')[0];
      }
    }

    const createdEvent = await import('./apple-calendar').then(m =>
      m.createEvent(email, appPassword, calendarId, {
        title: event.title!,
        description: event.description,
        location: event.location,
        url: event.url,
        recurrence: event.recurrence,
        start,
        end
      })
    );

    return {
      id: createdEvent.id,
      title: createdEvent.title,
      description: createdEvent.description,
      start: { dateTime: createdEvent.startDate }, 
      end: { dateTime: createdEvent.endDate },
      location: createdEvent.location,
      source: 'apple',
      calendarId,
      calendarTitle: '', // Fetch if needed
    } as CalendarEvent;
  } else if (connection.provider === 'synology') {
    const [username, password] = connection.accessToken.split(':');
    const serverUrl = connection.refreshToken;

    if (!username || !password || !serverUrl) throw new Error('Invalid Synology credentials');
    if (!event.title) throw new Error('Event title is required');
    if (!event.start || !event.end) throw new Error('Event start and end times are required');

    const createdEvent = await import('./synology-calendar').then(m =>
      m.createEvent(serverUrl, username, password, calendarId, {
        title: event.title!,
        description: event.description,
        location: event.location,
        url: event.url,
        recurrence: event.recurrence,
        start: event.start!,
        end: event.end!
      })
    );

    return {
      id: createdEvent.id,
      title: createdEvent.title,
      description: createdEvent.description,
      start: { dateTime: createdEvent.startDate }, 
      end: { dateTime: createdEvent.endDate },
      location: createdEvent.location,
      source: 'synology',
      calendarId,
      calendarTitle: '',
    } as CalendarEvent;
  }

  throw new Error(`Provider ${connection.provider} does not support creating events yet.`);
};

/**
 * Update an existing calendar event
 */
export const updateCalendarEvent = async (
  connection: CalendarConnection,
  calendarId: string,
  eventId: string,
  event: Partial<CalendarEvent>
): Promise<CalendarEvent> => {
  if (connection.provider === 'google') {
    // Refresh token if needed
    let accessToken = connection.accessToken;
    if (isTokenExpired(connection.expiresAt)) {
      const newToken = await refreshGoogleToken(connection);
      if (newToken) accessToken = newToken;
      else throw new Error('Failed to refresh token');
    }

    const oauth2Client = initializeGoogleOAuth(
      process.env.GOOGLE_CLIENT_ID || '',
      process.env.GOOGLE_CLIENT_SECRET || '',
      process.env.GOOGLE_REDIRECT_URI || ''
    );

    // Map to Google format
    const rrule = toRRule(event.recurrence);
    const googleEvent: any = {};
    if (event.title !== undefined) googleEvent.summary = event.title;
    if (event.description !== undefined) googleEvent.description = event.description;
    if (event.start !== undefined) googleEvent.start = event.start;
    if (event.end !== undefined) googleEvent.end = event.end;
    if (event.location !== undefined) googleEvent.location = event.location;
    if (rrule) googleEvent.recurrence = [rrule];
    if (event.url) googleEvent.source = { url: event.url, title: event.url };

    // Google adds _date suffix for instances. Editing base series only.
    const baseEventId = eventId.split('_')[0];

    const updatedEvent = await import('./google-calendar').then(m =>
      m.updateEvent(oauth2Client, accessToken, calendarId, baseEventId, googleEvent)
    );

    return {
      id: updatedEvent.id,
      title: updatedEvent.summary,
      description: updatedEvent.description,
      start: updatedEvent.start,
      end: updatedEvent.end,
      location: updatedEvent.location,
      source: 'google',
      calendarId,
      calendarTitle: '',
    } as CalendarEvent;
  } else if (connection.provider === 'outlook') {
    let accessToken = connection.accessToken;
    if (isTokenExpired(connection.expiresAt)) {
      const newToken = await refreshOutlookToken(connection);
      if (newToken) accessToken = newToken;
      else throw new Error('Failed to refresh token');
    }

    // Extract base series ID for Outlook
    const baseEventId = eventId.includes('::') ? eventId.split('::')[0] : eventId;

    const startDate = event.start?.dateTime ? new Date(event.start.dateTime) : new Date();
    const updatedEvent = await updateOutlookEvent(accessToken, calendarId, baseEventId, {
      summary: event.title,
      description: event.description,
      start: event.start,
      end: event.end,
      location: event.location,
      allDay: event.allDay,
      recurrence: toOutlookRecurrence(event.recurrence, startDate),
    });

    return {
      id: updatedEvent.id,
      title: updatedEvent.summary,
      description: updatedEvent.description,
      start: updatedEvent.start,
      end: updatedEvent.end,
      location: updatedEvent.location,
      allDay: updatedEvent.allDay,
      source: 'outlook',
      calendarId,
      calendarTitle: '',
    } as CalendarEvent;
  } else if (connection.provider === 'apple') {
    const [email, appPassword] = connection.accessToken.split(':');

    // Normalize for Apple updates too
    if (event.allDay) {
      if (event.start && event.start.dateTime && !event.start.date) {
        event.start.date = event.start.dateTime.split('T')[0];
        delete event.start.dateTime;
      }
      if (event.end && event.end.dateTime && !event.end.date) {
        event.end.date = event.end.dateTime.split('T')[0];
        delete event.end.dateTime;
      }

      if (event.start && event.end && event.start.date && event.end.date && event.start.date === event.end.date) {
        const d = new Date(event.end.date);
        d.setDate(d.getDate() + 1);
        event.end.date = d.toISOString().split('T')[0];
      }
    }

    const updatedEvent = await import('./apple-calendar').then(m =>
      m.updateEvent(email, appPassword, calendarId, eventId, {
        title: event.title,
        description: event.description,
        location: event.location,
        url: event.url,
        start: event.start,
        end: event.end
      })
    );

    return {
      id: updatedEvent.id,
      title: updatedEvent.title,
      description: updatedEvent.description,
      start: { dateTime: updatedEvent.startDate },
      end: { dateTime: updatedEvent.endDate },
      location: updatedEvent.location,
      url: updatedEvent.url,
      source: 'apple',
      calendarId,
      calendarTitle: '',
    } as CalendarEvent;
  } else if (connection.provider === 'synology') {
    const [username, password] = connection.accessToken.split(':');
    const serverUrl = connection.refreshToken;

    if (!username || !password || !serverUrl) throw new Error('Invalid Synology credentials');

    const updatedEvent = await import('./synology-calendar').then(m =>
      m.updateEvent(serverUrl, username, password, calendarId, eventId, {
        title: event.title,
        description: event.description,
        location: event.location,
        url: event.url,
        start: event.start,
        end: event.end
      })
    );

    return {
      id: updatedEvent.id,
      title: updatedEvent.title,
      description: updatedEvent.description,
      start: { dateTime: updatedEvent.startDate },
      end: { dateTime: updatedEvent.endDate },
      location: updatedEvent.location,
      url: updatedEvent.url,
      source: 'synology',
      calendarId,
      calendarTitle: '',
    } as CalendarEvent;
  }

  throw new Error(`Provider ${connection.provider} does not support updating events yet.`);
};

/**
 * Delete a calendar event
 */
export const deleteCalendarEvent = async (
  connection: CalendarConnection,
  calendarId: string,
  eventId: string
): Promise<void> => {
  if (connection.provider === 'google') {
    // Refresh token if needed
    let accessToken = connection.accessToken;
    if (isTokenExpired(connection.expiresAt)) {
      const newToken = await refreshGoogleToken(connection);
      if (newToken) accessToken = newToken;
      else throw new Error('Failed to refresh token');
    }

    const oauth2Client = initializeGoogleOAuth(
      process.env.GOOGLE_CLIENT_ID || '',
      process.env.GOOGLE_CLIENT_SECRET || '',
      process.env.GOOGLE_REDIRECT_URI || ''
    );

    // Default to deleting the whole series if repeating
    const baseEventId = eventId.split('_')[0];

    await import('./google-calendar').then(m =>
      m.deleteEvent(oauth2Client, accessToken, calendarId, baseEventId)
    );
    return;
  } else if (connection.provider === 'outlook') {
    let accessToken = connection.accessToken;
    if (isTokenExpired(connection.expiresAt)) {
      const newToken = await refreshOutlookToken(connection);
      if (newToken) accessToken = newToken;
      else throw new Error('Failed to refresh token');
    }

    // Extract base series ID for Outlook
    const baseEventId = eventId.includes('::') ? eventId.split('::')[0] : eventId;

    await deleteOutlookEvent(accessToken, calendarId, baseEventId);
    return;
  } else if (connection.provider === 'apple') {
    const [email, appPassword] = connection.accessToken.split(':');

    await import('./apple-calendar').then(m =>
      m.deleteEvent(email, appPassword, calendarId, eventId)
    );
    return;
  } else if (connection.provider === 'synology') {
    const [username, password] = connection.accessToken.split(':');
    const serverUrl = connection.refreshToken;

    if (!username || !password || !serverUrl) throw new Error('Invalid Synology credentials');

    await import('./synology-calendar').then(m =>
      m.deleteEvent(serverUrl, username, password, calendarId, eventId)
    );
    return;
  }

  throw new Error(`Provider ${connection.provider} does not support deleting events yet.`);
};