package fic

import (
	"encoding/hex"
	"fmt"
	"log"
	"time"
	"path"
)

type myTeamFile struct {
	Path     string `json:"path"`
	Name     string `json:"name"`
	Checksum string `json:"checksum"`
	Size     int64  `json:"size"`
}
type myTeamHint struct {
	HintId   int64   `json:"id"`
	Title    string  `json:"title"`
	Content  string  `json:"content,omitempty"`
	File     string  `json:"file,omitempty"`
	Cost     int64   `json:"cost"`
}
type myTeamMCQ struct {
	Title    string           `json:"title"`
	Justify  bool             `json:"justify,omitempty"`
	Choices  map[int64]string `json:"choices,omitempty"`
	Solved   *time.Time       `json:"solved,omitempty"`
}
type myTeamExercice struct {
	ThemeId      int          `json:"theme_id"`
	Statement    string       `json:"statement"`
	Hints        []myTeamHint `json:"hints,omitempty"`
	Gain         int          `json:"gain"`
	Files        []myTeamFile `json:"files,omitempty"`
	Flags        []string     `json:"keys,omitempty"`
	SolvedMat    []bool       `json:"solved_matrix,omitempty"`
	MCQs         []myTeamMCQ  `json:"mcqs,omitempty"`
	SolveDist    int64        `json:"solve_dist,omitempty"`
	SolvedTime   time.Time    `json:"solved_time,omitempty"`
	SolvedRank   int64        `json:"solved_rank,omitempty"`
	Tries        int64        `json:"tries,omitempty"`
	VideoURI     string       `json:"video_uri,omitempty"`
	Issue        string       `json:"issue,omitempty"`
	IssueKind    string       `json:"issuekind,omitempty"`
}
type myTeam struct {
	Id        int64                     `json:"team_id"`
	Name      string                    `json:"name"`
	Points    int64                     `json:"score"`
	Members   []Member                  `json:"members"`
	Exercices map[string]myTeamExercice `json:"exercices"`
}

func MyJSONTeam(t *Team, started bool) (interface{}, error) {
	ret := myTeam{}

	// Fill information about the team
	if t == nil {
		ret.Id = 0
	} else {
		ret.Name = t.Name
		ret.Id = t.Id
		points, _ := t.GetPoints()
		ret.Points = int64(points)
		if members, err := t.GetMembers(); err == nil {
			ret.Members = members
		}

	}

	// Fill exercices, only if the challenge is started
	ret.Exercices = map[string]myTeamExercice{}
	if exos, err := GetExercices(); err != nil {
		return ret, err
	} else if started {
		for _, e := range exos {
			if t == nil || t.HasAccess(e) {
				exercice := myTeamExercice{}
				if tid, err := e.GetThemeId(); err == nil {
					exercice.ThemeId = tid
				}

				exercice.Statement = e.Statement

				if len(e.Issue) > 0 {
					exercice.Issue = e.Issue
					exercice.IssueKind = e.IssueKind
				}

				if t == nil {
					if e.Overview != "" {
						exercice.Statement = e.Overview
					}
					exercice.VideoURI = e.VideoURI
					exercice.SolvedRank = 1
					exercice.Tries = e.TriedCount()
					exercice.Gain = int(float64(e.Gain) * e.Coefficient)
				} else {
					var solved bool
					solved, exercice.SolvedTime = t.HasSolved(e)
					exercice.SolvedRank, _ = t.GetSolvedRank(e)

					if solved {
						exercice.Tries, _ = t.CountTries(e)
					} else {
						exercice.Tries, exercice.SolvedTime = t.CountTries(e)
						if exercice.Tries > 0 {
							exercice.SolveDist = t.LastTryDist(e)
						}
					}

					if gain, err := e.EstimateGain(*t, solved); err == nil {
						exercice.Gain = int(gain)
					} else {
						log.Println("ERROR during gain estimation:", err)
					}
				}

				// Expose exercice files

				exercice.Files = []myTeamFile{}

				if files, err := e.GetFiles(); err != nil {
					return nil, err
				} else {
					for _, f := range files {
						if t == nil || t.CanDownload(f) {
							exercice.Files = append(exercice.Files, myTeamFile{path.Join(FilesDir, f.Path), f.Name, hex.EncodeToString(f.Checksum), f.Size})
						}
					}
				}

				// Expose exercice hints

				exercice.Hints = []myTeamHint{}

				if hints, err := e.GetHints(); err != nil {
					return nil, err
				} else {
					for _, h := range hints {
						if t == nil || t.HasHint(h) {
							exercice.Hints = append(exercice.Hints, myTeamHint{h.Id, h.Title, h.Content, h.File, h.Cost})
						} else {
							exercice.Hints = append(exercice.Hints, myTeamHint{h.Id, h.Title, "", "", h.Cost})
						}
					}
				}

				// Expose exercice flags

				var justifiedMCQ map[string]bool
				exercice.Flags = []string{}

				if flags, err := e.GetFlags(); err != nil {
					return nil, err
				} else {
					for _, k := range flags {
						if k.Label[0] == '%' {
							justifiedMCQ[k.Label[1:]] = true
						} else if t == nil {
							exercice.Flags = append(exercice.Flags, fmt.Sprintf("%x", k.Checksum)+k.Label)
						} else {
							exercice.Flags = append(exercice.Flags, k.Label)
							if PartialValidation {
								exercice.SolvedMat = append(exercice.SolvedMat, t.HasPartiallySolved(k) != nil)
							}
						}
					}
				}

				// Expose exercice MCQs

				exercice.MCQs = []myTeamMCQ{}

				if mcqs, err := e.GetMCQ(); err != nil {
					return nil, err
				} else {
					for _, mcq := range mcqs {
						choices := map[int64]string{}
						justified := false
						for _, e := range mcq.Entries {
							choices[e.Id] = e.Label
							if _, ok := justifiedMCQ[m.Title + "%" + e.Label]; ok {
								justified = true
							}
						}
						if t == nil {
							exercice.MCQs = append(exercice.MCQs, myTeamMCQ{mcq.Title, justified, choices, nil})
						} else {
							exercice.MCQs = append(exercice.MCQs, myTeamMCQ{mcq.Title, justified, choices, t.HasPartiallyRespond(mcq)})
						}
					}
				}

				// Hash table ordered by exercice Id
				ret.Exercices[fmt.Sprintf("%d", e.Id)] = exercice
			}
		}
	}

	return ret, nil
}