package main

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

	"cloud.google.com/go/datastore"
	"github.com/unrolled/secure"
	"google.golang.org/api/iterator"

	"go.skia.org/infra/go/baseapp"
	"go.skia.org/infra/go/httputils"
	"go.skia.org/infra/go/sklog"
)

const (
	sheriffs         = "Sheriffs"
	sheriffRotations = "SheriffSchedules"

	robocops         = "Robocops"
	robocopRotations = "RobocopSchedules"

	troopers         = "Troopers"
	trooperRotations = "TrooperSchedules"

	wranglers         = "GpuSheriffs"
	wranglerRotations = "GpuSheriffSchedules"
)

var (
	typeToRotations = map[string]string{
		sheriffs:  sheriffRotations,
		robocops:  robocopRotations,
		troopers:  trooperRotations,
		wranglers: wranglerRotations,
	}
)

type Rotation struct {
	Username      string    `json:"username" datastore:"username"`
	ScheduleStart time.Time `json:"schedule_start" datastore:"schedule_start"`
	ScheduleEnd   time.Time `json:"schedule_end" datastore:"schedule_end"`

	ReadableRange string `json:"readable_range" datastore:"-"`
	CurrentWeek   bool   `json:"current_week" datastore:"-"`

	Key *datastore.Key `json:"-" datastore:"-"`
}

type RotationMember struct {
	Username string `json:"username" datastore:"username"`
}

type RotationsTemplateContext struct {
	// Nonce is the CSP Nonce. Look in webpack.config.js for where the nonce
	// templates are injected.
	Nonce string

	RotationsType string
	RotationsDoc  string
	RotationsImg  string
	Rotations     []*Rotation
}

func getUpcomingRotations(rotations string, from time.Time) ([]*Rotation, error) {
	upcomingRotations := []*Rotation{}
	q := datastore.NewQuery(rotations).Namespace(*namespace).Filter("schedule_end >", from).Order("schedule_end")
	it := dsClient.Run(context.TODO(), q)
	for {
		r := &Rotation{}
		k, err := it.Next(r)
		if err == iterator.Done {
			break
		} else if err != nil {
			return nil, fmt.Errorf("Failed to retrieve list of rotations: %s", err)
		}
		_, startMonth, startDate := r.ScheduleStart.UTC().Date()
		_, endMonth, endDate := r.ScheduleEnd.UTC().Date()
		r.ReadableRange = fmt.Sprintf("%d %s - %d %s", startDate, startMonth, endDate, endMonth)
		r.Key = k
		upcomingRotations = append(upcomingRotations, r)
	}
	if len(upcomingRotations) > 0 {
		upcomingRotations[0].CurrentWeek = true
	}
	return upcomingRotations, nil
}

func getRotationMembers(rotationType string) ([]*RotationMember, error) {
	members := []*RotationMember{}
	q := datastore.NewQuery(rotationType).Namespace(*namespace)
	it := dsClient.Run(context.TODO(), q)
	for {
		r := &RotationMember{}
		_, err := it.Next(r)
		if err == iterator.Done {
			break
		} else if err != nil {
			return nil, fmt.Errorf("Failed to retrieve list of rotation members: %s", err)
		}
		members = append(members, r)
	}
	return members, nil
}

func addRotation(rotationType, username string, scheduleStart, scheduleEnd time.Time) error {
	r := &Rotation{
		Username:      username,
		ScheduleStart: scheduleStart,
		ScheduleEnd:   scheduleEnd,
	}

	key := &datastore.Key{
		Kind:      typeToRotations[rotationType],
		Namespace: *namespace,
	}
	_, err := dsClient.RunInTransaction(context.Background(), func(tx *datastore.Transaction) error {
		var err error
		if _, err = tx.Put(key, r); err != nil {
			return err
		}
		return nil
	})
	if err != nil {
		return fmt.Errorf("Failed to add rotation: %s", err)
	}
	return nil
}

// HTTP Handlers.

func (srv *Server) currentSheriffHandler(w http.ResponseWriter, r *http.Request) {
	srv.currentRotationHandler(w, r, sheriffRotations)
}

func (srv *Server) currentWranglerHandler(w http.ResponseWriter, r *http.Request) {
	srv.currentRotationHandler(w, r, wranglerRotations)
}

func (srv *Server) currentTrooperHandler(w http.ResponseWriter, r *http.Request) {
	srv.currentRotationHandler(w, r, trooperRotations)
}

func (srv *Server) currentRobocopHandler(w http.ResponseWriter, r *http.Request) {
	srv.currentRotationHandler(w, r, robocopRotations)
}

func (srv *Server) nextSheriffHandler(w http.ResponseWriter, r *http.Request) {
	srv.nextRotationHandler(w, r, sheriffRotations)
}

func (srv *Server) nextWranglerHandler(w http.ResponseWriter, r *http.Request) {
	srv.nextRotationHandler(w, r, wranglerRotations)
}

func (srv *Server) nextTrooperHandler(w http.ResponseWriter, r *http.Request) {
	srv.nextRotationHandler(w, r, trooperRotations)
}

func (srv *Server) nextRobocopHandler(w http.ResponseWriter, r *http.Request) {
	srv.nextRotationHandler(w, r, robocopRotations)
}

func (srv *Server) updateSheriffRotationsHandler(w http.ResponseWriter, r *http.Request) {
	srv.updateRotationsHandler(w, r, sheriffs, srv.sheriffHandler)
}

func (srv *Server) updateWranglerRotationsHandler(w http.ResponseWriter, r *http.Request) {
	srv.updateRotationsHandler(w, r, wranglers, srv.wranglerHandler)
}

func (srv *Server) updateRobocopRotationsHandler(w http.ResponseWriter, r *http.Request) {
	srv.updateRotationsHandler(w, r, robocops, srv.robocopHandler)
}

func (srv *Server) updateTrooperRotationsHandler(w http.ResponseWriter, r *http.Request) {
	srv.updateRotationsHandler(w, r, troopers, srv.trooperHandler)
}

func (srv *Server) sheriffHandler(w http.ResponseWriter, r *http.Request) {
	rotations, err := getUpcomingRotations(sheriffRotations, time.Now().UTC())
	if err != nil {
		httputils.ReportError(w, err, "Failed to get sheriff rotations.", http.StatusInternalServerError)
		return
	}
	templateContext := RotationsTemplateContext{
		Nonce:         secure.CSPNonce(r.Context()),
		RotationsType: "Sheriff",
		RotationsDoc:  "https://skia.org/dev/sheriffing",
		RotationsImg:  "sheriff.jpg",
		Rotations:     rotations,
	}
	if err := srv.commonRotationsHandler(w, r, templateContext); err != nil {
		httputils.ReportError(w, err, "Failed to expand template.", http.StatusInternalServerError)
		return
	}
}

func (srv *Server) wranglerHandler(w http.ResponseWriter, r *http.Request) {
	rotations, err := getUpcomingRotations(wranglerRotations, time.Now().UTC())
	if err != nil {
		httputils.ReportError(w, err, "Failed to get wrangler rotations.", http.StatusInternalServerError)
		return
	}
	templateContext := RotationsTemplateContext{
		Nonce:         secure.CSPNonce(r.Context()),
		RotationsType: "Wrangler",
		RotationsDoc:  "https://skia.org/dev/sheriffing/gpu",
		RotationsImg:  "wrangler.jpg",
		Rotations:     rotations,
	}
	if err := srv.commonRotationsHandler(w, r, templateContext); err != nil {
		httputils.ReportError(w, err, "Failed to expand template.", http.StatusInternalServerError)
		return
	}
}

func (srv *Server) robocopHandler(w http.ResponseWriter, r *http.Request) {
	rotations, err := getUpcomingRotations(robocopRotations, time.Now().UTC())
	if err != nil {
		httputils.ReportError(w, err, "Failed to get robocop rotations.", http.StatusInternalServerError)
		return
	}
	templateContext := RotationsTemplateContext{
		Nonce:         secure.CSPNonce(r.Context()),
		RotationsType: "Android Robocop",
		RotationsDoc:  "https://skia.org/dev/sheriffing/android",
		RotationsImg:  "robocop.jpg",
		Rotations:     rotations,
	}
	if err := srv.commonRotationsHandler(w, r, templateContext); err != nil {
		httputils.ReportError(w, err, "Failed to expand template.", http.StatusInternalServerError)
		return
	}
}

func (srv *Server) trooperHandler(w http.ResponseWriter, r *http.Request) {
	rotations, err := getUpcomingRotations(trooperRotations, time.Now().UTC())
	if err != nil {
		httputils.ReportError(w, err, "Failed to get trooper rotations.", http.StatusInternalServerError)
		return
	}
	templateContext := RotationsTemplateContext{
		Nonce:         secure.CSPNonce(r.Context()),
		RotationsType: "Infra Trooper",
		RotationsDoc:  "https://skia.org/dev/sheriffing/trooper",
		RotationsImg:  "trooper.jpg",
		Rotations:     rotations,
	}
	if err := srv.commonRotationsHandler(w, r, templateContext); err != nil {
		httputils.ReportError(w, err, "Failed to expand template.", http.StatusInternalServerError)
		return
	}
}

// HTTP Handler helpers.

func (srv *Server) currentRotationHandler(w http.ResponseWriter, r *http.Request, rotations string) {
	w.Header().Set("Content-Type", "application/json")

	upcomingRotations, err := getUpcomingRotations(rotations, time.Now().UTC())
	if err != nil {
		httputils.ReportError(w, err, "Failed to get sheriff rotations.", http.StatusInternalServerError)
		return
	}
	var rotation interface{}
	if len(upcomingRotations) == 0 {
		rotation = map[string]string{}
	} else {
		rotation = upcomingRotations[0]
	}
	if err := json.NewEncoder(w).Encode(rotation); err != nil {
		sklog.Errorf("Failed to send response: %s", err)
	}
}

func (srv *Server) nextRotationHandler(w http.ResponseWriter, r *http.Request, rotations string) {
	w.Header().Set("Content-Type", "application/json")

	upcomingRotations, err := getUpcomingRotations(rotations, time.Now().UTC())
	if err != nil {
		httputils.ReportError(w, err, "Failed to get sheriff rotations.", http.StatusInternalServerError)
		return
	}
	var rotation interface{}
	if len(upcomingRotations) < 2 {
		rotation = map[string]string{}
	} else {
		rotation = upcomingRotations[1]
	}
	if err := json.NewEncoder(w).Encode(rotation); err != nil {
		sklog.Errorf("Failed to send response: %s", err)
	}
}

func (srv *Server) commonRotationsHandler(w http.ResponseWriter, r *http.Request, templateContext RotationsTemplateContext) error {
	w.Header().Set("Content-Type", "text/html")
	if *baseapp.Local {
		srv.loadTemplates()
	}
	if err := srv.templates.ExecuteTemplate(w, "rotations.html", templateContext); err != nil {
		return fmt.Errorf("Failed to expand template: %s", err)
	}
	return nil
}

func (srv *Server) updateRotationsHandler(w http.ResponseWriter, r *http.Request, rotationType string, redirectHandler func(w http.ResponseWriter, r *http.Request)) {
	user := srv.user(r)
	if !srv.admin.Member(user) {
		httputils.ReportError(w, nil, "You do not have access to update rotations.", http.StatusInternalServerError)
		return
	}

	scheduleStart := r.URL.Query().Get("schedule_start")
	weeks := r.URL.Query().Get("weeks")
	if scheduleStart == "" || weeks == "" {
		httputils.ReportError(w, nil, "Must specify schedule_start and weeks parameters. Eg: ?schedule_start=2020-01-31&weeks=5", http.StatusBadRequest)
		return
	}
	from, err := time.Parse(time.RFC3339, fmt.Sprintf("%sT00:00:00Z", scheduleStart))
	if err != nil {
		httputils.ReportError(w, nil, fmt.Sprintf("schedule_start must be in format of 2020-01-31 not %s", scheduleStart), http.StatusBadRequest)
		return
	}
	if from.Weekday() != time.Monday {
		httputils.ReportError(w, nil, fmt.Sprintf("schedule_start must be a Monday not %s", from.Weekday()), http.StatusBadRequest)
		return
	}
	weeksInt, err := strconv.Atoi(weeks)
	if err != nil || weeksInt < 1 {
		httputils.ReportError(w, nil, fmt.Sprintf("weeks must be an int>1 not %s", weeks), http.StatusBadRequest)
		return
	}

	members, err := getRotationMembers(rotationType)
	if err != nil {
		httputils.ReportError(w, err, fmt.Sprintf("Failed to get %s rotation members.", rotationType), http.StatusInternalServerError)
		return
	}

	sklog.Infof("Going to update rotations of %s with %d members\n", rotationType, len(members))
	sklog.Infof("Starting at %s for %d weeks\n", from, weeksInt)

	// Clear out any rotations that exist in the time range we want to populate.
	rotations, err := getUpcomingRotations(typeToRotations[rotationType], from.UTC())
	if err != nil {
		httputils.ReportError(w, err, fmt.Sprintf("Failed to get rotations of %s.", rotationType), http.StatusInternalServerError)
		return
	}
	for _, rotation := range rotations {
		sklog.Infof("Going to delete %+v rotation\n", rotation)
		if err := dsClient.Delete(r.Context(), rotation.Key); err != nil {
			httputils.ReportError(w, err, fmt.Sprintf("Could not delete rotations of %s after %s.", rotationType, from), http.StatusInternalServerError)
			return
		}
	}

	membersIndex := 0
	currScheduleFrom := from
	for week := 1; week <= weeksInt; week++ {
		currScheduleEnd := currScheduleFrom.Add(time.Hour * 24 * 6)
		sklog.Infof("Adding %s for %s to %s\n", members[membersIndex].Username, currScheduleFrom, currScheduleEnd)
		if err := addRotation(rotationType, members[membersIndex].Username, currScheduleFrom, currScheduleEnd); err != nil {
			httputils.ReportError(w, err, fmt.Sprintf("Could not create new rotations of %s.", rotationType), http.StatusInternalServerError)
			return
		}
		currScheduleFrom = currScheduleFrom.Add(time.Hour * 24 * 7)
		membersIndex = (membersIndex + 1) % len(members)
	}

	redirectHandler(w, r)
}