package scheduling

import (
	"encoding/json"
	"fmt"
	"net/http"
	"time"

	"crussell/db"
)

// --- Types ---
type DefaultHours struct {
	Weekday   int    `json:"weekday"`
	StartTime string `json:"startTime"`
	EndTime   string `json:"endTime"`
	IsOpen    bool   `json:"isOpen"`
}

type ExceptionalHours struct {
	ID        int    `json:"id"`
	GroupID   int    `json:"groupId"`
	Weekday   int    `json:"weekday"`
	StartTime string `json:"startTime"`
	EndTime   string `json:"endTime"`
	IsOpen    bool   `json:"isOpen"`
}

type ExceptionalGroup struct {
	ID          int                `json:"id"`
	Name        string             `json:"name"`
	Description string             `json:"description"`
	Hours       []ExceptionalHours `json:"hours,omitempty"` // 7 entries
}

type ExceptionalApplication struct {
	ID        int    `json:"id"`
	GroupID   int    `json:"groupId"`
	WeekStart string `json:"weekStart"` // Monday date
}

type DayWorkingHours struct {
	Date      string `json:"date"`
	Weekday   int    `json:"weekday"`
	StartTime string `json:"startTime"`
	EndTime   string `json:"endTime"`
	IsOpen    bool   `json:"isOpen"`
	Source    string `json:"source"` // "default" or "exceptional"
}

// --- Default Hours Handlers ---
func GetDefaultHours(w http.ResponseWriter, r *http.Request) {
	rows, err := db.DB.Query(r.Context(), `
		SELECT weekday, start_time::text, end_time::text, is_open
		FROM working_hours ORDER BY weekday
	`)
	if err != nil {
		http.Error(w, "failed to fetch default hours", http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var hours []DefaultHours
	for rows.Next() {
		var h DefaultHours
		if err := rows.Scan(&h.Weekday, &h.StartTime, &h.EndTime, &h.IsOpen); err != nil {
			http.Error(w, "failed to scan default hours", http.StatusInternalServerError)
			return
		}
		hours = append(hours, h)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(hours)
}

func UpdateDefaultHours(w http.ResponseWriter, r *http.Request) {
	var hours []DefaultHours
	if err := json.NewDecoder(r.Body).Decode(&hours); err != nil {
		http.Error(w, "invalid payload", http.StatusBadRequest)
		return
	}

	tx, err := db.DB.Begin(r.Context())
	if err != nil {
		http.Error(w, "failed to start tx", http.StatusInternalServerError)
		return
	}
	defer tx.Rollback(r.Context())

	for _, h := range hours {
		_, err := tx.Exec(r.Context(), `
			UPDATE working_hours
			SET start_time=$1,end_time=$2,is_open=$3
			WHERE weekday=$4
		`, h.StartTime, h.EndTime, h.IsOpen, h.Weekday)
		if err != nil {
			http.Error(w, "failed to update default hours", http.StatusInternalServerError)
			return
		}
	}

	if err := tx.Commit(r.Context()); err != nil {
		http.Error(w, "failed to commit", http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

// --- Exceptional Groups & Hours ---
func ListExceptionalGroups(w http.ResponseWriter, r *http.Request) {
	rows, err := db.DB.Query(r.Context(), `
		SELECT id,name,description
		FROM exceptional_working_hours_groups
		ORDER BY id DESC
	`)
	if err != nil {
		http.Error(w, "failed to fetch groups", http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var groups []ExceptionalGroup
	for rows.Next() {
		var g ExceptionalGroup
		if err := rows.Scan(&g.ID, &g.Name, &g.Description); err != nil {
			http.Error(w, "failed to scan group", http.StatusInternalServerError)
			return
		}
		// load 7-day hours
		hoursRows, _ := db.DB.Query(r.Context(), `
			SELECT id, weekday, start_time::text, end_time::text, is_open
			FROM exceptional_working_hours
			WHERE group_id=$1 ORDER BY weekday
		`, g.ID)
		for hoursRows.Next() {
			var h ExceptionalHours
			if err := hoursRows.Scan(&h.ID, &h.Weekday, &h.StartTime, &h.EndTime, &h.IsOpen); err == nil {
				h.GroupID = g.ID
				g.Hours = append(g.Hours, h)
			}
		}
		hoursRows.Close()
		groups = append(groups, g)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(groups)
}

func CreateExceptionalGroup(w http.ResponseWriter, r *http.Request) {
	var g ExceptionalGroup
	if err := json.NewDecoder(r.Body).Decode(&g); err != nil {
		http.Error(w, "invalid payload", http.StatusBadRequest)
		return
	}
	if len(g.Hours) != 7 {
		http.Error(w, "must provide 7 weekday entries", http.StatusBadRequest)
		return
	}

	tx, err := db.DB.Begin(r.Context())
	if err != nil {
		http.Error(w, "failed to start tx", http.StatusInternalServerError)
		return
	}
	defer tx.Rollback(r.Context())

	err = tx.QueryRow(r.Context(), `
		INSERT INTO exceptional_working_hours_groups (name, description)
		VALUES ($1,$2) RETURNING id
	`, g.Name, g.Description).Scan(&g.ID)
	if err != nil {
		http.Error(w, "failed to create group", http.StatusInternalServerError)
		return
	}

	for _, h := range g.Hours {
		_, err := tx.Exec(r.Context(), `
			INSERT INTO exceptional_working_hours (group_id, weekday, start_time, end_time, is_open)
			VALUES ($1,$2,$3,$4,$5)
		`, g.ID, h.Weekday, h.StartTime, h.EndTime, h.IsOpen)
		if err != nil {
			http.Error(w, "failed to insert group hours", http.StatusInternalServerError)
			return
		}
	}

	if err := tx.Commit(r.Context()); err != nil {
		http.Error(w, "failed to commit", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(g)
}

// --- Exceptional Applications (assign a group to a week) ---
func ListExceptionalApplications(w http.ResponseWriter, r *http.Request) {
	rows, err := db.DB.Query(r.Context(), `
		SELECT id, group_id, week_start
		FROM exceptional_group_applications
		ORDER BY week_start DESC
	`)
	if err != nil {
		http.Error(w, "failed to fetch applications", http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var list []ExceptionalApplication
	for rows.Next() {
		var a ExceptionalApplication
		var weekStart time.Time
		if err := rows.Scan(&a.ID, &a.GroupID, &weekStart); err != nil {
			http.Error(w, "failed to scan application", http.StatusInternalServerError)
			return
		}
		a.WeekStart = weekStart.Format("2006-01-02")
		list = append(list, a)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(list)
}

func CreateExceptionalApplication(w http.ResponseWriter, r *http.Request) {
	var a ExceptionalApplication
	if err := json.NewDecoder(r.Body).Decode(&a); err != nil {
		http.Error(w, "invalid payload", http.StatusBadRequest)
		return
	}
	weekStart, err := time.Parse("2006-01-02", a.WeekStart)
	if err != nil {
		http.Error(w, "invalid week_start format, expected YYYY-MM-DD", http.StatusBadRequest)
		return
	}

	err = db.DB.QueryRow(r.Context(), `
		INSERT INTO exceptional_group_applications (group_id, week_start)
		VALUES ($1,$2)
		RETURNING id
	`, a.GroupID, weekStart).Scan(&a.ID)
	if err != nil {
		http.Error(w, "failed to create application", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(a)
}

// --- GetWorkingHours (merged default + applied exceptions) ---
func GetWorkingHours(w http.ResponseWriter, r *http.Request) {
	startStr := r.URL.Query().Get("start")
	endStr := r.URL.Query().Get("end")
	if startStr == "" || endStr == "" {
		http.Error(w, "start and end query params required", http.StatusBadRequest)
		return
	}
	start, err := time.Parse("2006-01-02", startStr)
	if err != nil {
		http.Error(w, "invalid start date", http.StatusBadRequest)
		return
	}
	end, err := time.Parse("2006-01-02", endStr)
	if err != nil {
		http.Error(w, "invalid end date", http.StatusBadRequest)
		return
	}

	// Load default hours
	defaultMap := map[int]DefaultHours{}
	defRows, _ := db.DB.Query(r.Context(), `
		SELECT weekday, start_time::text, end_time::text, is_open
		FROM working_hours
	`)
	for defRows.Next() {
		var d DefaultHours
		if err := defRows.Scan(&d.Weekday, &d.StartTime, &d.EndTime, &d.IsOpen); err == nil {
			defaultMap[d.Weekday] = d
		}
	}
	defRows.Close()

	// Load exceptional applications in range
	appRows, _ := db.DB.Query(r.Context(), `
		SELECT a.group_id, a.week_start
		FROM exceptional_group_applications a
		WHERE a.week_start <= $1 AND a.week_start >= $2 - INTERVAL '6 days'
	`, end, start) // any week overlapping the range
	type appEntry struct {
		GroupID   int
		WeekStart time.Time
	}
	var apps []appEntry
	for appRows.Next() {
		var e appEntry
		if err := appRows.Scan(&e.GroupID, &e.WeekStart); err == nil {
			apps = append(apps, e)
		}
	}
	appRows.Close()

	// Load exceptional
	// Load exceptional hours for all relevant groups
	groupIDs := []int{}
	for _, a := range apps {
		groupIDs = append(groupIDs, a.GroupID)
	}

	exHoursMap := map[int]map[int]ExceptionalHours{} // groupID -> weekday -> hours
	if len(groupIDs) > 0 {
		query, args, _ := sqlIn("SELECT group_id, weekday, start_time::text, end_time::text, is_open FROM exceptional_working_hours WHERE group_id IN (?)", groupIDs)
		rows, _ := db.DB.Query(r.Context(), query, args...)
		for rows.Next() {
			var h ExceptionalHours
			if err := rows.Scan(&h.GroupID, &h.Weekday, &h.StartTime, &h.EndTime, &h.IsOpen); err == nil {
				if _, ok := exHoursMap[h.GroupID]; !ok {
					exHoursMap[h.GroupID] = map[int]ExceptionalHours{}
				}
				exHoursMap[h.GroupID][h.Weekday] = h
			}
		}
		rows.Close()
	}

	// Generate final result per day
	var results []DayWorkingHours
	for d := start; !d.After(end); d = d.AddDate(0, 0, 1) {
		weekday := int(d.Weekday())
		if weekday == 0 {
			weekday = 6 // Go Sunday=0 -> our Sunday=6
		} else {
			weekday -= 1 // shift Monday=0 ... Sunday=6
		}

		// find applied group for this week
		var applied *ExceptionalHours
		weekStart := d.AddDate(0, 0, -weekday) // Monday of current week
		for _, a := range apps {
			if a.WeekStart.Equal(weekStart) {
				if dayHours, ok := exHoursMap[a.GroupID][weekday]; ok {
					applied = &dayHours
				}
				break
			}
		}

		var day DayWorkingHours
		day.Date = d.Format("2006-01-02")
		day.Weekday = weekday

		if applied != nil {
			day.StartTime = applied.StartTime
			day.EndTime = applied.EndTime
			day.IsOpen = applied.IsOpen
			day.Source = "exceptional"
		} else if def, ok := defaultMap[weekday]; ok {
			day.StartTime = def.StartTime
			day.EndTime = def.EndTime
			day.IsOpen = def.IsOpen
			day.Source = "default"
		} else {
			day.StartTime = "00:00"
			day.EndTime = "00:00"
			day.IsOpen = false
			day.Source = "default"
		}

		results = append(results, day)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(results)
}

// --- helper: sqlIn generates IN queries dynamically for Postgres ---
func sqlIn(query string, args []int) (string, []interface{}, error) {
	inArgs := []interface{}{}
	placeholders := ""
	for i, arg := range args {
		if i > 0 {
			placeholders += ","
		}
		placeholders += fmt.Sprintf("$%d", i+1)
		inArgs = append(inArgs, arg)
	}
	query = fmt.Sprintf(query, placeholders)
	return query, inArgs, nil
}

// --- Types for Available Hours ---
type TimeSlot struct {
	StartTime string `json:"startTime"`
	EndTime   string `json:"endTime"`
}

type DayAvailableHours struct {
	Date    string     `json:"date"`
	Weekday int        `json:"weekday"`
	IsOpen  bool       `json:"isOpen"`
	Slots   []TimeSlot `json:"slots"`  // Can have gaps (lunch, bookings, etc.)
	Source  string     `json:"source"` // "default" or "exceptional"
}

// --- GetAvailableHours (working hours with gaps for lunch, bookings, etc.) ---
func GetAvailableHours(w http.ResponseWriter, r *http.Request) {
	startStr := r.URL.Query().Get("start")
	endStr := r.URL.Query().Get("end")
	if startStr == "" || endStr == "" {
		http.Error(w, "start and end query params required", http.StatusBadRequest)
		return
	}

	// Load UK timezone
	ukLocation, err := time.LoadLocation("Europe/London")
	if err != nil {
		http.Error(w, "failed to load timezone", http.StatusInternalServerError)
		return
	}

	// Parse dates in UK timezone
	start, err := time.ParseInLocation("2006-01-02", startStr, ukLocation)
	if err != nil {
		http.Error(w, "invalid start date", http.StatusBadRequest)
		return
	}
	end, err := time.ParseInLocation("2006-01-02", endStr, ukLocation)
	if err != nil {
		http.Error(w, "invalid end date", http.StatusBadRequest)
		return
	}

	// Set to start of day (00:00:00) and end of day (23:59:59)
	start = time.Date(start.Year(), start.Month(), start.Day(), 0, 0, 0, 0, ukLocation)
	end = time.Date(end.Year(), end.Month(), end.Day(), 23, 59, 59, 999999999, ukLocation)

	// Load default hours
	defaultMap := map[int]DefaultHours{}
	defRows, _ := db.DB.Query(r.Context(), `
		SELECT weekday, start_time::text, end_time::text, is_open
		FROM working_hours
	`)
	for defRows.Next() {
		var d DefaultHours
		if err := defRows.Scan(&d.Weekday, &d.StartTime, &d.EndTime, &d.IsOpen); err == nil {
			defaultMap[d.Weekday] = d
		}
	}
	defRows.Close()

	// Load exceptional applications in range
	appRows, _ := db.DB.Query(r.Context(), `
		SELECT a.group_id, a.week_start
		FROM exceptional_group_applications a
		WHERE a.week_start <= $1 AND a.week_start >= $2 - INTERVAL '6 days'
	`, end, start)
	type appEntry struct {
		GroupID   int
		WeekStart time.Time
	}
	var apps []appEntry
	for appRows.Next() {
		var e appEntry
		if err := appRows.Scan(&e.GroupID, &e.WeekStart); err == nil {
			apps = append(apps, e)
		}
	}
	appRows.Close()

	// Load exceptional hours for all relevant groups
	groupIDs := []int{}
	for _, a := range apps {
		groupIDs = append(groupIDs, a.GroupID)
	}

	exHoursMap := map[int]map[int]ExceptionalHours{} // groupID -> weekday -> hours
	if len(groupIDs) > 0 {
		query, args, _ := sqlIn("SELECT group_id, weekday, start_time::text, end_time::text, is_open FROM exceptional_working_hours WHERE group_id IN (?)", groupIDs)
		rows, _ := db.DB.Query(r.Context(), query, args...)
		for rows.Next() {
			var h ExceptionalHours
			if err := rows.Scan(&h.GroupID, &h.Weekday, &h.StartTime, &h.EndTime, &h.IsOpen); err == nil {
				if _, ok := exHoursMap[h.GroupID]; !ok {
					exHoursMap[h.GroupID] = map[int]ExceptionalHours{}
				}
				exHoursMap[h.GroupID][h.Weekday] = h
			}
		}
		rows.Close()
	}

	// Load bookings with their total duration (sum of all services)
	bookingRows, err := db.DB.Query(r.Context(), `
    SELECT 
        b.start_time,
        COALESCE(SUM(s.duration_minutes), 0) as total_duration
    FROM bookings b
    LEFT JOIN booking_services bs ON b.id = bs.booking_id
    LEFT JOIN services s ON bs.service_id = s.id
    WHERE b.start_time >= $1 
        AND b.start_time <= $2
    GROUP BY b.id, b.start_time
    ORDER BY b.start_time
`, start, end)

	if err != nil {
		http.Error(w, "failed to query bookings", http.StatusInternalServerError)
		return
	}

	bookings := map[string][]TimeSlot{} // date -> booked slots
	for bookingRows.Next() {
		var startTime time.Time
		var durationMinutes int
		if err := bookingRows.Scan(&startTime, &durationMinutes); err == nil {
			// Convert to UK timezone for date formatting
			startTimeUK := startTime.In(ukLocation)
			dateStr := startTimeUK.Format("2006-01-02")
			endTime := startTimeUK.Add(time.Duration(durationMinutes) * time.Minute)

			bookings[dateStr] = append(bookings[dateStr], TimeSlot{
				StartTime: startTimeUK.Format("15:04"),
				EndTime:   endTime.Format("15:04"),
			})
		}
	}
	bookingRows.Close()

	// Generate final result per day with gaps
	var results []DayAvailableHours
	for d := start; !d.After(end); d = d.AddDate(0, 0, 1) {
		weekday := int(d.Weekday())
		if weekday == 0 {
			weekday = 6 // Go Sunday=0 -> our Sunday=6
		} else {
			weekday -= 1 // shift Monday=0 ... Sunday=6
		}

		// Find applied group for this week
		var applied *ExceptionalHours
		weekStart := d.AddDate(0, 0, -weekday) // Monday of current week
		for _, a := range apps {
			if a.WeekStart.Equal(weekStart) {
				if dayHours, ok := exHoursMap[a.GroupID][weekday]; ok {
					applied = &dayHours
				}
				break
			}
		}

		var day DayAvailableHours
		day.Date = d.Format("2006-01-02")
		day.Weekday = weekday

		// Determine base working hours and source
		var baseStart, baseEnd string
		var isOpen bool
		if applied != nil {
			baseStart = applied.StartTime
			baseEnd = applied.EndTime
			isOpen = applied.IsOpen
			day.Source = "exceptional"
		} else if def, ok := defaultMap[weekday]; ok {
			baseStart = def.StartTime
			baseEnd = def.EndTime
			isOpen = def.IsOpen
			day.Source = "default"
		} else {
			baseStart = "00:00"
			baseEnd = "00:00"
			isOpen = false
			day.Source = "default"
		}

		day.IsOpen = isOpen

		if isOpen {
			// Start with the full working hours as one slot
			allSlots := []TimeSlot{{StartTime: baseStart, EndTime: baseEnd}}

			// Apply gaps from bookings
			dateStr := day.Date
			if booked, ok := bookings[dateStr]; ok {
				allSlots = subtractTimeSlots(allSlots, booked)
			}

			day.Slots = allSlots
		} else {
			day.Slots = []TimeSlot{}
		}

		results = append(results, day)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(results)
}

// subtractTimeSlots removes gaps from available slots
// Returns the remaining available time slots after removing the gaps
func subtractTimeSlots(available []TimeSlot, gaps []TimeSlot) []TimeSlot {
	if len(gaps) == 0 {
		return available
	}

	result := []TimeSlot{}

	for _, slot := range available {
		current := []TimeSlot{slot}

		// Apply each gap
		for _, gap := range gaps {
			var temp []TimeSlot
			for _, s := range current {
				// Check if gap overlaps with this slot
				if gap.EndTime <= s.StartTime || gap.StartTime >= s.EndTime {
					// No overlap, keep the slot as is
					temp = append(temp, s)
				} else {
					// Overlap exists, split the slot
					if s.StartTime < gap.StartTime {
						// Keep the part before the gap
						temp = append(temp, TimeSlot{
							StartTime: s.StartTime,
							EndTime:   gap.StartTime,
						})
					}
					if gap.EndTime < s.EndTime {
						// Keep the part after the gap
						temp = append(temp, TimeSlot{
							StartTime: gap.EndTime,
							EndTime:   s.EndTime,
						})
					}
				}
			}
			current = temp
		}

		result = append(result, current...)
	}

	return result
}