package api

import (
	"context"
	"fmt"
	"log"
	"sort"
	"strings"
	"sync"
	"time"

	"task-dashboard/internal/models"

	"google.golang.org/api/calendar/v3"
	"google.golang.org/api/option"
)

type GoogleCalendarClient struct {
	srv         *calendar.Service
	calendarIDs []string
	displayTZ   *time.Location
}

// parseEventTime extracts start/end times from a Google Calendar event
func (c *GoogleCalendarClient) parseEventTime(item *calendar.Event) (start, end time.Time) {
	displayTZ := c.displayTZ
	if displayTZ == nil {
		displayTZ = time.UTC
	}

	if item.Start.DateTime == "" {
		// All-day event - parse in display timezone
		start, _ = time.ParseInLocation("2006-01-02", item.Start.Date, displayTZ)
		end, _ = time.ParseInLocation("2006-01-02", item.End.Date, displayTZ)
	} else {
		// Try RFC3339 first (includes timezone offset like "2006-01-02T15:04:05-10:00" or "Z")
		var err error
		start, err = time.Parse(time.RFC3339, item.Start.DateTime)
		if err != nil {
			// No timezone in string - use event's timezone or display timezone
			var loc *time.Location
			if item.Start.TimeZone != "" {
				loc, _ = time.LoadLocation(item.Start.TimeZone)
			}
			if loc == nil {
				loc = displayTZ
			}
			start, _ = time.ParseInLocation("2006-01-02T15:04:05", item.Start.DateTime, loc)
		}

		end, err = time.Parse(time.RFC3339, item.End.DateTime)
		if err != nil {
			var loc *time.Location
			if item.End.TimeZone != "" {
				loc, _ = time.LoadLocation(item.End.TimeZone)
			}
			if loc == nil {
				loc = displayTZ
			}
			end, _ = time.ParseInLocation("2006-01-02T15:04:05", item.End.DateTime, loc)
		}

		// Convert to display timezone
		start = start.In(displayTZ)
		end = end.In(displayTZ)
	}
	return
}

// deduplicateEvents removes duplicate events (same summary + start time)
func deduplicateEvents(events []models.CalendarEvent) []models.CalendarEvent {
	seen := make(map[string]bool)
	var unique []models.CalendarEvent
	for _, event := range events {
		key := fmt.Sprintf("%s|%d", event.Summary, event.Start.Unix())
		if !seen[key] {
			seen[key] = true
			unique = append(unique, event)
		}
	}
	sort.Slice(unique, func(i, j int) bool {
		return unique[i].Start.Before(unique[j].Start)
	})
	return unique
}

// NewGoogleCalendarClient creates a client that fetches from multiple calendars.
// calendarIDs can be comma-separated (e.g., "cal1@group.calendar.google.com,cal2@group.calendar.google.com")
// timezone is the IANA timezone name for display (e.g., "Pacific/Honolulu")
func NewGoogleCalendarClient(ctx context.Context, credentialsFile, calendarIDs, timezone string) (*GoogleCalendarClient, error) {
	srv, err := calendar.NewService(ctx, option.WithCredentialsFile(credentialsFile))
	if err != nil {
		return nil, fmt.Errorf("unable to retrieve Calendar client: %v", err)
	}

	// Parse comma-separated calendar IDs
	ids := strings.Split(calendarIDs, ",")
	var trimmedIDs []string
	for _, id := range ids {
		if trimmed := strings.TrimSpace(id); trimmed != "" {
			trimmedIDs = append(trimmedIDs, trimmed)
		}
	}

	// Load display timezone
	displayTZ, err := time.LoadLocation(timezone)
	if err != nil {
		log.Printf("Warning: invalid timezone %q, using UTC: %v", timezone, err)
		displayTZ = time.UTC
	}

	return &GoogleCalendarClient{
		srv:         srv,
		calendarIDs: trimmedIDs,
		displayTZ:   displayTZ,
	}, nil
}

func (c *GoogleCalendarClient) GetUpcomingEvents(ctx context.Context, maxResults int) ([]models.CalendarEvent, error) {
	t := time.Now().Format(time.RFC3339)

	fetchOne := func(calendarID string) []models.CalendarEvent {
		events, err := c.srv.Events.List(calendarID).ShowDeleted(false).
			SingleEvents(true).TimeMin(t).MaxResults(int64(maxResults)).OrderBy("startTime").
			Context(ctx).Do()
		if err != nil {
			log.Printf("Warning: failed to fetch events from calendar %s: %v", calendarID, err)
			return nil
		}
		parsed := make([]models.CalendarEvent, 0, len(events.Items))
		for _, item := range events.Items {
			start, end := c.parseEventTime(item)
			parsed = append(parsed, models.CalendarEvent{
				ID:               item.Id,
				Summary:          item.Summary,
				Description:      item.Description,
				Start:            start,
				End:              end,
				HTMLLink:         item.HtmlLink,
				RecurringEventID: item.RecurringEventId,
			})
		}
		return parsed
	}

	allEvents := c.fetchAllCalendars(fetchOne)

	uniqueEvents := deduplicateEvents(allEvents)
	if len(uniqueEvents) > maxResults {
		uniqueEvents = uniqueEvents[:maxResults]
	}
	return uniqueEvents, nil
}

// fetchAllCalendars runs fetchOne for every configured calendar concurrently
// and merges the results. This must be concurrent, not sequential: every
// caller shares a single deadline-bound ctx (see aggregateData's per-fetch
// context.WithTimeout in internal/handlers/handlers.go), and a sequential
// loop would let an early calendar's slow response starve the deadline
// budget for calendars later in the list -- exactly the failure mode this
// function exists to prevent (see incident notes 2026-08-04). Running them
// concurrently means every calendar gets an equal shot at the same shared
// deadline instead of eating into the next one's share of it.
func (c *GoogleCalendarClient) fetchAllCalendars(fetchOne func(calendarID string) []models.CalendarEvent) []models.CalendarEvent {
	var wg sync.WaitGroup
	var mu sync.Mutex
	var allEvents []models.CalendarEvent

	for _, calendarID := range c.calendarIDs {
		wg.Add(1)
		go func(calendarID string) {
			defer wg.Done()
			events := fetchOne(calendarID)
			if len(events) == 0 {
				return
			}
			mu.Lock()
			allEvents = append(allEvents, events...)
			mu.Unlock()
		}(calendarID)
	}
	wg.Wait()

	return allEvents
}

func (c *GoogleCalendarClient) GetEventsByDateRange(ctx context.Context, start, end time.Time) ([]models.CalendarEvent, error) {
	timeMin := start.Format(time.RFC3339)
	timeMax := end.Format(time.RFC3339)

	fetchOne := func(calendarID string) []models.CalendarEvent {
		events, err := c.srv.Events.List(calendarID).ShowDeleted(false).
			SingleEvents(true).TimeMin(timeMin).TimeMax(timeMax).OrderBy("startTime").
			Context(ctx).Do()
		if err != nil {
			log.Printf("Warning: failed to fetch events from calendar %s: %v", calendarID, err)
			return nil
		}
		parsed := make([]models.CalendarEvent, 0, len(events.Items))
		for _, item := range events.Items {
			evtStart, evtEnd := c.parseEventTime(item)
			parsed = append(parsed, models.CalendarEvent{
				ID:               item.Id,
				Summary:          item.Summary,
				Description:      item.Description,
				Start:            evtStart,
				End:              evtEnd,
				HTMLLink:         item.HtmlLink,
				RecurringEventID: item.RecurringEventId,
			})
		}
		return parsed
	}

	return deduplicateEvents(c.fetchAllCalendars(fetchOne)), nil
}

// SetCalendarIDs updates the calendar IDs used by the client
func (c *GoogleCalendarClient) SetCalendarIDs(ids []string) {
	c.calendarIDs = ids
}

// GetCalendarList returns all calendars accessible to the user
func (c *GoogleCalendarClient) GetCalendarList(ctx context.Context) ([]models.CalendarInfo, error) {
	list, err := c.srv.CalendarList.List().Context(ctx).Do()
	if err != nil {
		return nil, fmt.Errorf("failed to fetch calendar list: %w", err)
	}

	var calendars []models.CalendarInfo
	for _, item := range list.Items {
		name := item.Summary
		if name == "" {
			name = item.Id
		}
		calendars = append(calendars, models.CalendarInfo{
			ID:   item.Id,
			Name: name,
		})
	}
	return calendars, nil
}