package handlers

import (
	"context"
	"net/http"
	"strconv"
	"time"

	"git.haelnorr.com/h/golib/hws"
	"git.haelnorr.com/h/oslstats/internal/contexts"
	"git.haelnorr.com/h/oslstats/internal/db"
	"git.haelnorr.com/h/oslstats/internal/notify"
	"git.haelnorr.com/h/oslstats/internal/permissions"
	"git.haelnorr.com/h/oslstats/internal/respond"
	"git.haelnorr.com/h/oslstats/internal/throw"
	"git.haelnorr.com/h/oslstats/internal/validation"
	"git.haelnorr.com/h/oslstats/internal/view/seasonsview"
	"git.haelnorr.com/h/timefmt"
	"github.com/pkg/errors"
	"github.com/uptrace/bun"
)

// FixtureDetailPage renders the fixture detail page with scheduling UI, history,
// result display, and team rosters
func FixtureDetailPage(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}

		activeTab := r.URL.Query().Get("tab")
		if activeTab == "" {
			activeTab = "overview"
		}

		var fixture *db.Fixture
		var currentSchedule *db.FixtureSchedule
		var history []*db.FixtureSchedule
		var canSchedule bool
		var userTeamID int
		var result *db.FixtureResult
		var rosters map[string][]*db.PlayerWithPlayStatus
		var nominatedFreeAgents []*db.FixtureFreeAgent
		var availableFreeAgents []*db.SeasonLeagueFreeAgent

		if ok := conn.WithReadTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			var err error
			fixture, err = db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					throw.NotFound(s, w, r, r.URL.Path)
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}
			currentSchedule, err = db.GetCurrentFixtureSchedule(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetCurrentFixtureSchedule")
			}
			history, err = db.GetFixtureScheduleHistory(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureScheduleHistory")
			}
			user := db.CurrentUser(ctx)
			canSchedule, userTeamID, err = fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			// Fetch fixture result if it exists
			result, err = db.GetFixtureResult(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureResult")
			}
			// Fetch team rosters with play status
			rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
			}
			// Fetch free agent nominations for this fixture
			nominatedFreeAgents, err = db.GetNominatedFreeAgents(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetNominatedFreeAgents")
			}
			// Fetch available free agents for nomination (if user can schedule or manage fixtures)
			canManage := contexts.Permissions(ctx).HasPermission(permissions.FixturesManage)
			if canSchedule || canManage {
				availableFreeAgents, err = db.GetFreeAgentsForSeasonLeague(ctx, tx, fixture.SeasonID, fixture.LeagueID)
				if err != nil {
					return false, errors.Wrap(err, "db.GetFreeAgentsForSeasonLeague")
				}
			}
			return true, nil
		}); !ok {
			return
		}

		renderSafely(seasonsview.FixtureDetailPage(
			fixture, currentSchedule, history, canSchedule, userTeamID,
			result, rosters, activeTab, nominatedFreeAgents, availableFreeAgents,
		), s, r, w)
	})
}

// ProposeSchedule handles POST /fixtures/{fixture_id}/schedule
func ProposeSchedule(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}

		getter, ok := validation.ParseFormOrNotify(s, w, r)
		if !ok {
			return
		}
		format := timefmt.NewBuilder().Year4().Dash().MonthNumeric2().Dash().
			DayNumeric2().T().Hour24().Colon().Minute().Build()
		aest, _ := time.LoadLocation("Australia/Sydney")
		// scheduledTime := getter.TimeInLocation("scheduled_time", format, aest).After(time.Now()).Value
		scheduledTime := getter.TimeInLocation("scheduled_time", format, aest).Value

		if !getter.ValidateAndNotify(s, w, r) {
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			fixture, err := db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}

			user := db.CurrentUser(ctx)
			canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			if !canSchedule {
				throw.Forbidden(s, w, r, "You must be a team manager to propose a schedule", nil)
				return false, nil
			}

			_, err = db.ProposeFixtureSchedule(ctx, tx, fixtureID, userTeamID, scheduledTime, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Propose", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.ProposeFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.SuccessWithDelay(s, w, r, "Time Proposed", "Your proposed time has been submitted.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}

// AcceptSchedule handles POST /fixtures/{fixture_id}/schedule/{schedule_id}/accept
func AcceptSchedule(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}
		scheduleID, err := strconv.Atoi(r.PathValue("schedule_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid schedule ID", err)
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			fixture, err := db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}

			user := db.CurrentUser(ctx)
			canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			if !canSchedule {
				throw.Forbidden(s, w, r, "You must be a team manager to accept a schedule", nil)
				return false, nil
			}

			err = db.AcceptFixtureSchedule(ctx, tx, scheduleID, userTeamID, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Accept", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.AcceptFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.Success(s, w, r, "Schedule Accepted", "The fixture time has been confirmed.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}

// RejectSchedule handles POST /fixtures/{fixture_id}/schedule/{schedule_id}/reject
func RejectSchedule(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}
		scheduleID, err := strconv.Atoi(r.PathValue("schedule_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid schedule ID", err)
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			fixture, err := db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}

			user := db.CurrentUser(ctx)
			canSchedule, _, err := fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			if !canSchedule {
				throw.Forbidden(s, w, r, "You must be a team manager to reject a schedule", nil)
				return false, nil
			}

			err = db.RejectFixtureSchedule(ctx, tx, scheduleID, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Reject", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.RejectFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.Success(s, w, r, "Schedule Rejected", "The proposed time has been rejected.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}

// PostponeSchedule handles POST /fixtures/{fixture_id}/schedule/postpone
func PostponeSchedule(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}

		getter, ok := validation.ParseFormOrNotify(s, w, r)
		if !ok {
			return
		}
		reason := getter.String("reschedule_reason").TrimSpace().Required().Value
		if !getter.ValidateAndNotify(s, w, r) {
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			fixture, err := db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}

			user := db.CurrentUser(ctx)
			canSchedule, _, err := fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			if !canSchedule {
				throw.Forbidden(s, w, r, "You must be a team manager to postpone a fixture", nil)
				return false, nil
			}

			err = db.PostponeFixtureSchedule(ctx, tx, fixtureID, reason, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Postpone", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.PostponeFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.Success(s, w, r, "Fixture Postponed", "The fixture has been postponed.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}

// RescheduleFixture handles POST /fixtures/{fixture_id}/schedule/reschedule
func RescheduleFixture(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}

		getter, ok := validation.ParseFormOrNotify(s, w, r)
		if !ok {
			return
		}
		format := timefmt.NewBuilder().Year4().Dash().MonthNumeric2().Dash().
			DayNumeric2().T().Hour24().Colon().Minute().Build()
		aest, _ := time.LoadLocation("Australia/Sydney")
		scheduledTime := getter.TimeInLocation("scheduled_time", format, aest).After(time.Now()).Value
		reason := getter.String("reschedule_reason").TrimSpace().Required().Value

		if !getter.ValidateAndNotify(s, w, r) {
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			fixture, err := db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}

			user := db.CurrentUser(ctx)
			canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			if !canSchedule {
				throw.Forbidden(s, w, r, "You must be a team manager to reschedule a fixture", nil)
				return false, nil
			}

			_, err = db.RescheduleFixtureSchedule(ctx, tx, fixtureID, userTeamID, scheduledTime, reason, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Reschedule", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.RescheduleFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.Success(s, w, r, "Fixture Rescheduled", "The new proposed time has been submitted.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}

// WithdrawSchedule handles POST /fixtures/{fixture_id}/schedule/{schedule_id}/withdraw
// Only the proposing team manager can withdraw their own pending proposal.
func WithdrawSchedule(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}
		scheduleID, err := strconv.Atoi(r.PathValue("schedule_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid schedule ID", err)
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			fixture, err := db.GetFixture(ctx, tx, fixtureID)
			if err != nil {
				if db.IsBadRequest(err) {
					respond.NotFound(w, errors.Wrap(err, "db.GetFixture"))
					return false, nil
				}
				return false, errors.Wrap(err, "db.GetFixture")
			}

			user := db.CurrentUser(ctx)
			canSchedule, userTeamID, err := fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			if !canSchedule {
				throw.Forbidden(s, w, r, "You must be a team manager to withdraw a proposal", nil)
				return false, nil
			}

			err = db.WithdrawFixtureSchedule(ctx, tx, scheduleID, userTeamID, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Withdraw", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.WithdrawFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.Success(s, w, r, "Proposal Withdrawn", "Your proposed time has been withdrawn.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}

// CancelSchedule handles POST /fixtures/{fixture_id}/schedule/cancel
// This is a moderator-only action that requires fixtures.manage permission.
func CancelSchedule(
	s *hws.Server,
	conn *db.DB,
) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fixtureID, err := strconv.Atoi(r.PathValue("fixture_id"))
		if err != nil {
			throw.BadRequest(s, w, r, "Invalid fixture ID", err)
			return
		}

		getter, ok := validation.ParseFormOrNotify(s, w, r)
		if !ok {
			return
		}
		reason := getter.String("reschedule_reason").TrimSpace().Required().Value
		if !getter.ValidateAndNotify(s, w, r) {
			return
		}

		if ok := conn.WithNotifyTx(s, w, r, func(ctx context.Context, tx bun.Tx) (bool, error) {
			err := db.CancelFixtureSchedule(ctx, tx, fixtureID, reason, db.NewAuditFromRequest(r))
			if err != nil {
				if db.IsBadRequest(err) {
					notify.Warn(s, w, r, "Cannot Cancel", err.Error(), nil)
					return false, nil
				}
				return false, errors.Wrap(err, "db.CancelFixtureSchedule")
			}
			return true, nil
		}); !ok {
			return
		}

		notify.Success(s, w, r, "Forfeit Declared", "The fixture has been declared a forfeit.", nil)
		respond.HXRedirect(w, "/fixtures/%d", fixtureID)
	})
}