package handlers

import (
	"context"
	"fmt"
	"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 redirects to the default tab (overview)
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
		}

		http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/overview", fixtureID), http.StatusSeeOther)
	})
}

// FixtureDetailOverviewPage renders the overview tab of the fixture detail page
func FixtureDetailOverviewPage(
	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
		}

		var fixture *db.Fixture
		var currentSchedule *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")
			}
			user := db.CurrentUser(ctx)
			canSchedule, userTeamID, err = fixture.CanSchedule(ctx, tx, user)
			if err != nil {
				return false, errors.Wrap(err, "fixture.CanSchedule")
			}
			result, err = db.GetFixtureResult(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureResult")
			}
			rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
			}
			nominatedFreeAgents, err = db.GetNominatedFreeAgents(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetNominatedFreeAgents")
			}
			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
		}

		if r.Method == "GET" {
			renderSafely(seasonsview.FixtureDetailOverviewPage(
				fixture, currentSchedule, canSchedule, userTeamID,
				result, rosters, nominatedFreeAgents, availableFreeAgents,
			), s, r, w)
		} else {
			renderSafely(seasonsview.FixtureDetailOverviewContent(
				fixture, currentSchedule, canSchedule, userTeamID,
				result, rosters, nominatedFreeAgents, availableFreeAgents,
			), s, r, w)
		}
	})
}

// FixtureDetailPreviewPage renders the match preview tab of the fixture detail page
func FixtureDetailPreviewPage(
	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
		}

		var fixture *db.Fixture
		var result *db.FixtureResult
		var rosters map[string][]*db.PlayerWithPlayStatus
		var previewData *db.MatchPreviewData

		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")
			}
			result, err = db.GetFixtureResult(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureResult")
			}
			rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
			}
			previewData, err = db.ComputeMatchPreview(ctx, tx, fixture)
			if err != nil {
				return false, errors.Wrap(err, "db.ComputeMatchPreview")
			}
			return true, nil
		}); !ok {
			return
		}

		// If finalized, redirect to analysis instead
		if result != nil && result.Finalized {
			if r.Method == "GET" {
				http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/analysis", fixtureID), http.StatusSeeOther)
			} else {
				respond.HXRedirect(w, "/fixtures/%d/analysis", fixtureID)
			}
			return
		}

		if r.Method == "GET" {
			renderSafely(seasonsview.FixtureDetailPreviewPage(
				fixture, result, rosters, previewData,
			), s, r, w)
		} else {
			renderSafely(seasonsview.FixtureDetailPreviewContent(
				fixture, rosters, previewData,
			), s, r, w)
		}
	})
}

// FixtureDetailAnalysisPage renders the match analysis tab of the fixture detail page
func FixtureDetailAnalysisPage(
	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
		}

		var fixture *db.Fixture
		var result *db.FixtureResult
		var rosters map[string][]*db.PlayerWithPlayStatus
		var previewData *db.MatchPreviewData

		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")
			}
			result, err = db.GetFixtureResult(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureResult")
			}
			rosters, err = db.GetFixtureTeamRosters(ctx, tx, fixture, result)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureTeamRosters")
			}
			previewData, err = db.ComputeMatchPreview(ctx, tx, fixture)
			if err != nil {
				return false, errors.Wrap(err, "db.ComputeMatchPreview")
			}
			return true, nil
		}); !ok {
			return
		}

		// If not finalized, redirect to preview instead
		if result == nil || !result.Finalized {
			if r.Method == "GET" {
				http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/preview", fixtureID), http.StatusSeeOther)
			} else {
				respond.HXRedirect(w, "/fixtures/%d/preview", fixtureID)
			}
			return
		}

		if r.Method == "GET" {
			renderSafely(seasonsview.FixtureDetailAnalysisPage(
				fixture, result, rosters, previewData,
			), s, r, w)
		} else {
			renderSafely(seasonsview.FixtureDetailAnalysisContent(
				fixture, result, rosters, previewData,
			), s, r, w)
		}
	})
}

// FixtureDetailSchedulePage renders the schedule tab of the fixture detail page
func FixtureDetailSchedulePage(
	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
		}

		var fixture *db.Fixture
		var currentSchedule *db.FixtureSchedule
		var history []*db.FixtureSchedule
		var canSchedule bool
		var userTeamID int
		var result *db.FixtureResult

		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")
			}
			result, err = db.GetFixtureResult(ctx, tx, fixtureID)
			if err != nil {
				return false, errors.Wrap(err, "db.GetFixtureResult")
			}
			return true, nil
		}); !ok {
			return
		}

		// If finalized, redirect to overview (scheduling tab is hidden)
		if result != nil && result.Finalized {
			if r.Method == "GET" {
				http.Redirect(w, r, fmt.Sprintf("/fixtures/%d/overview", fixtureID), http.StatusSeeOther)
			} else {
				respond.HXRedirect(w, "/fixtures/%d/overview", fixtureID)
			}
			return
		}

		if r.Method == "GET" {
			renderSafely(seasonsview.FixtureDetailSchedulePage(
				fixture, currentSchedule, history, canSchedule, userTeamID,
			), s, r, w)
		} else {
			renderSafely(seasonsview.FixtureDetailScheduleContent(
				fixture, currentSchedule, history, canSchedule, userTeamID,
			), 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)
	})
}