package server

import (
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"strconv"
	"time"

	"github.com/google/uuid"
	"streifling.com/jason/sicherheitsunterweisung/packages/db"
	"streifling.com/jason/sicherheitsunterweisung/packages/types"
)

func displayTable(w http.ResponseWriter, db *db.DB) {
	bs, err := db.GetAllOverviewTableData()
	if err != nil {
		http.Error(w, "displayTable: *DB.GetAllOverviewTableData(): "+fmt.Sprint(err), http.StatusInternalServerError)
	}
	template.Must(template.ParseFiles("templates/table.html")).ExecuteTemplate(w, "content", bs)
}

func HandleInternalLogin(ss *[]*types.Session, cs chan<- *types.Session, db *db.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		instructors, err := db.GetInstructors()
		if err != nil {
			http.Error(w, "HandleInternalLogin: db.GetInstructors(): "+fmt.Sprint(err), http.StatusInternalServerError)
			log.Panicln(err)
		}

		for _, i := range instructors {
			if r.PostFormValue("login") == fmt.Sprint(i.ID) {
				session := new(types.Session)
				session.ID = uuid.New()
				session.Briefing = new(types.Briefing)
				session.Briefing.InstructorID = i.ID
				(*ss) = append((*ss), session)
				cs <- session

				displayTable(w, db)
				return
			}
		}
		template.Must(template.ParseFiles("templates/login.html")).ExecuteTemplate(w, "content", nil)
	}
}

func HandleSearch(db *db.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		bs, err := db.GetOverviewTableDataByName(r.PostFormValue("search"))
		if err != nil {
			http.Error(w, "DisplayResults: db.ReadByName(r.PostFormValue()): "+fmt.Sprint(err), http.StatusInternalServerError)
		}
		template.Must(template.ParseFiles("templates/table.html")).ExecuteTemplate(w, "rows", bs)
	}
}

func HandleNewBriefing(s *types.Session) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		type httpData struct {
			SessionID uuid.UUID
		}

		data := new(httpData)
		data.SessionID = s.ID

		template.Must(template.ParseFiles("templates/briefing.html")).ExecuteTemplate(w, "content", data)
	}
}

func generateLogin() (string, error) {
	bs := make([]byte, 4)

	if _, err := rand.Read(bs); err != nil {
		return "", fmt.Errorf("generateLogin: rand.Read(bs): %v\n", err)
	}

	return hex.EncodeToString(bs), nil
}

func HandleNewParticipant(s *types.Session, cp chan<- *types.Participant) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		type httpData struct {
			SessionID uuid.UUID
			Login     string
		}

		data := new(httpData)
		var err error

		p := new(types.Participant)
		p.Login, err = generateLogin()
		if err != nil {
			http.Error(w, "AddParticipant: generateLogin(): "+fmt.Sprint(err), http.StatusInternalServerError)
		}
		s.Participants = append(s.Participants, p)
		cp <- p

		data.SessionID = s.ID
		data.Login = p.Login
		if err != nil {
			http.Error(w, "AddParticipant: generateLogin(): "+fmt.Sprint(err), http.StatusInternalServerError)
		}

		template.Must(template.ParseFiles("templates/briefing.html")).ExecuteTemplate(w, "new", data)
	}
}

func HandleBriefingForm(s *types.Session, db *db.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		now := time.Now()
		var err error

		s.Briefing.Date = now.Format("2006-01-02")
		s.Briefing.Time = now.Format("15:04:05")
		s.Briefing.Location = r.PostFormValue("location")
		s.Briefing.DocumentName = r.PostFormValue("document")
		s.Briefing.AsOf = r.PostFormValue("as-of")

		err = db.WriteBriefing(s.Briefing)
		if err != nil {
			http.Error(w, "SubmitBriefingForm: db.WriteBriefing(): "+fmt.Sprint(err), http.StatusInternalServerError)
			log.Panicln(err)
		}

		displayTable(w, db)
	}
}

// TODO: Make it only serve one purpose
func findCorrectLogin(l string, ss *[]*types.Session) (*types.Session, *types.Participant, bool) {
	for _, session := range *ss {
		for _, p := range session.Participants {
			if l == p.Login {
				return session, p, true
			}
		}
	}
	return nil, nil, false
}

func newParticipant(l string) (*types.Participant, error) {
	var err error
	p := new(types.Participant)

	p.ID, err = strconv.ParseInt(l, 10, 64)
	if err != nil {
		return nil, fmt.Errorf("newParticipant: strconv.Atoi(idString): %v\n", err)
	}

	return p, nil
}

func HandleExternalLogin(ss *[]*types.Session) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		type httpData struct {
			SessionID uuid.UUID
			Login     string
		}

		session, participant, loginCorrect := findCorrectLogin(r.PostFormValue("login"), ss)
		if loginCorrect {
			data := new(httpData)
			data.SessionID = session.ID
			data.Login = participant.Login

			template.Must(template.ParseFiles("templates/participant.html")).ExecuteTemplate(w, "content", data)
		} else {
			template.Must(template.ParseFiles("templates/login.html")).ExecuteTemplate(w, "content", nil)
		}
	}
}

func handleGivenAnswer(s *types.Session, p *types.Participant, i int64, r *http.Request, db *db.DB) error {
	answer, err := strconv.Atoi(r.PostFormValue("answer"))
	if err != nil {
		return fmt.Errorf("handleGivenAnswer: strconv.Atoi(): %v\n", err)
	}

	if err := db.WriteGivenAnswer(s.Briefing, p, &s.Questions[i], answer); err != nil {
		return fmt.Errorf("handleGivenAnswer: db.WriteGivenAnswer(): %v\n", err)
	}

	return nil
}

func HandleParticipant(s *types.Session, p *types.Participant, sq *[]types.Question, db *db.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		type httpData struct {
			SessionID  uuid.UUID
			Login      string
			Question   types.Question
			QuestionID int64
		}

		p.FirstName = r.PostFormValue("first-" + fmt.Sprint(p.Login))
		p.LastName = r.PostFormValue("last-" + fmt.Sprint(p.Login))
		p.Company = r.PostFormValue("company-" + fmt.Sprint(p.Login))

		err := db.WriteParticipant(p)
		if err != nil {
			http.Error(w, "DisplayQuestion: db.WriteParticipant(): "+fmt.Sprint(err), http.StatusInternalServerError)
			log.Panicln(err)
		}

		data := new(httpData)
		data.SessionID = s.ID
		data.Login = p.Login
		data.Question = (*sq)[0]
		data.QuestionID = 1

		template.Must(template.ParseFiles("templates/question.html")).ExecuteTemplate(w, "content", data)
	}
}

func HandleAnswer(s *types.Session, db *db.DB, p *types.Participant, sq *[]types.Question, i int64) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		log.Println(i, len(*sq))
		if i < int64(len(*sq)) {
			type httpData struct {
				SessionID  uuid.UUID
				Login      string
				Question   types.Question
				QuestionID int64
			}

			if err := handleGivenAnswer(s, p, i-1, r, db); err != nil {
				http.Error(w, "DisplayQuestion: handleGivenAnswer(): "+fmt.Sprint(err), http.StatusInternalServerError)
				log.Panicln(err)
			}

			data := new(httpData)
			data.SessionID = s.ID
			data.Login = p.Login
			data.Question = (*sq)[i]
			data.QuestionID = i + 1

			template.Must(template.ParseFiles("templates/question.html")).ExecuteTemplate(w, "content", data)
		} else {
			type answer struct {
				Text    string
				Correct bool
				Chosen  bool
			}

			type question struct {
				Text    string
				Answers []answer
			}

			type httpData struct {
				SessionID uuid.UUID
				Login     string
				Questions []question
				Incorrect int
			}

			if err := handleGivenAnswer(s, p, i-1, r, db); err != nil {
				http.Error(w, "DisplayTestResults: handleGivenAnswer(): "+fmt.Sprint(err), http.StatusInternalServerError)
				log.Panicln(err)
			}

			givenAnswers, err := db.GetGivenAnswers(s.Briefing.ID, p.ID, s.Questions)
			if err != nil {
				http.Error(w, "DisplayTestResults: db.GetGivenAnswers(): "+fmt.Sprint(err), http.StatusInternalServerError)
				log.Panicln(err)
			}

			data := new(httpData)
			data.SessionID = s.ID
			data.Login = p.Login
			data.Incorrect = 0

			data.Questions = make([]question, 0)
			for i, q := range s.Questions {
				question := new(question)
				question.Text = q.Text

				question.Answers = make([]answer, 0)
				for j, a := range q.Answers {
					answer := new(answer)
					answer.Text = a.Text

					if j+1 == q.Correct {
						answer.Correct = true
					} else {
						answer.Correct = false
					}

					if j+1 == givenAnswers[i] {
						answer.Chosen = true
					} else {
						answer.Chosen = false
					}
					question.Answers = append(question.Answers, *answer)
				}
				data.Questions = append(data.Questions, *question)

				if givenAnswers[i] != q.Correct {
					data.Incorrect++
				}
			}

			template.Must(template.ParseFiles("templates/results.html")).ExecuteTemplate(w, "content", data)
		}
	}
}

func HandleRetry(s *types.Session, p *types.Participant, sq *[]types.Question) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		type httpData struct {
			SessionID  uuid.UUID
			Login      string
			Question   types.Question
			QuestionID int64
		}

		data := new(httpData)
		data.SessionID = s.ID
		data.Login = p.Login
		data.Question = (*sq)[0]
		data.QuestionID = 1

		template.Must(template.ParseFiles("templates/question.html")).ExecuteTemplate(w, "content", data)
	}
}