package api

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

	"task-dashboard/internal/models"

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

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

// parseEventTime extracts start/end times from a Google Calendar event, converting to local timezone
func parseEventTime(item *calendar.Event) (start, end time.Time) {
	if item.Start.DateTime == "" {
		// All-day event - parse in local timezone
		start, _ = time.ParseInLocation("2006-01-02", item.Start.Date, time.Local)
		end, _ = time.ParseInLocation("2006-01-02", item.End.Date, time.Local)
	} else {
		// Timed event - parse RFC3339 then convert to local
		start, _ = time.Parse(time.RFC3339, item.Start.DateTime)
		end, _ = time.Parse(time.RFC3339, item.End.DateTime)
		start = start.Local()
		end = end.Local()
	}
	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")
func NewGoogleCalendarClient(ctx context.Context, credentialsFile, calendarIDs string) (*GoogleCalendarClient, error) {
	// Use type-safe credential loading (replaces deprecated WithCredentialsFile)
	srv, err := calendar.NewService(ctx, option.WithAuthCredentialsFile(option.ServiceAccount, 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)
		}
	}

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

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

	for _, calendarID := range c.calendarIDs {
		events, err := c.srv.Events.List(calendarID).ShowDeleted(false).
			SingleEvents(true).TimeMin(t).MaxResults(int64(maxResults)).OrderBy("startTime").Do()
		if err != nil {
			log.Printf("Warning: failed to fetch events from calendar %s: %v", calendarID, err)
			continue
		}

		for _, item := range events.Items {
			start, end := parseEventTime(item)
			allEvents = append(allEvents, models.CalendarEvent{
				ID:          item.Id,
				Summary:     item.Summary,
				Description: item.Description,
				Start:       start,
				End:         end,
				HTMLLink:    item.HtmlLink,
			})
		}
	}

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

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

	for _, calendarID := range c.calendarIDs {
		events, err := c.srv.Events.List(calendarID).ShowDeleted(false).
			SingleEvents(true).TimeMin(timeMin).TimeMax(timeMax).OrderBy("startTime").Do()
		if err != nil {
			log.Printf("Warning: failed to fetch events from calendar %s: %v", calendarID, err)
			continue
		}

		for _, item := range events.Items {
			evtStart, evtEnd := parseEventTime(item)
			allEvents = append(allEvents, models.CalendarEvent{
				ID:          item.Id,
				Summary:     item.Summary,
				Description: item.Description,
				Start:       evtStart,
				End:         evtEnd,
				HTMLLink:    item.HtmlLink,
			})
		}
	}

	return deduplicateEvents(allEvents), nil
}