package main

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"path"
	"strconv"
	"time"

	"srs.epita.fr/fic-server/libfic"
)

var ApiTeamsRouting = map[string]DispatchFunction{
	"GET":    listTeam,
	"PUT":    creationTeamMembers,
	"POST":   creationTeam,
	"DELETE": deletionTeam,
}

type myTeamFile struct {
	Path     string `json:"path"`
	Name     string `json:"name"`
	Checksum string `json:"checksum"`
	Size     int64  `json:"size"`
}
type myTeamExercice struct {
	Statement    string       `json:"statement"`
	Hint         string       `json:"hint"`
	Gain         int64        `json:"gain"`
	Files        []myTeamFile `json:"files"`
	Keys         []string     `json:"keys"`
	Solved       bool         `json:"solved"`
	SolvedTime   time.Time    `json:"solved_time"`
	SolvedNumber int64        `json:"solved_number"`
}
type myTeam struct {
	Id        int64                     `json:"team_id"`
	Exercices map[string]myTeamExercice `json:"exercices"`
}

func myJSONTeam(t fic.Team) (interface{}, error) {
	ret := myTeam{}
	ret.Id = t.Id
	ret.Exercices = map[string]myTeamExercice{}

	if exos, err := fic.GetExercices(); err != nil {
		return ret, err
	} else {
		for _, e := range exos {
			if t.HasAccess(e) {
				exercice := myTeamExercice{}
				exercice.Statement = e.Statement
				exercice.Hint = e.Hint
				exercice.Solved, exercice.SolvedTime, exercice.SolvedNumber = t.HasSolved(e)

				exercice.Keys = []string{}

				if keys, err := e.GetKeys(); err != nil {
					return nil, err
				} else {
					for _, k := range keys {
						exercice.Keys = append(exercice.Keys, k.Type)
					}
				}

				exercice.Files = []myTeamFile{}

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

				ret.Exercices[fmt.Sprintf("%d", e.Id)] = exercice
			}
		}
	}

	return ret, nil
}

func nginxGenTeam() (string, error) {
	if teams, err := fic.GetTeams(); err != nil {
		return "", err
	} else {
		ret := ""
		for _, team := range teams {
			ret += fmt.Sprintf("        if ($ssl_client_s_dn ~ \"/C=FR/ST=France/O=Epita/OU=SRS/CN=%s\") { set $team %d; }\n", team.Name, team.Id)
		}

		return ret, nil
	}
}

type exportedTeam struct {
	Name    string       `json:"name"`
	Color   string       `json:"color"`
	Rank    int          `json:"rank"`
	Points  int64        `json:"score"`
	Members []fic.Member `json:"members"`
}

func exportTeams() (interface{}, error) {
	if teams, err := fic.GetTeams(); err != nil {
		return nil, err
	} else if rank, err := fic.GetRank(); err != nil {
		return nil, err
	} else {
		ret := map[string]exportedTeam{}
		for _, team := range teams {
			if points, err := team.GetPoints(); err != nil {
				return nil, err
			} else if members, err := team.GetMembers(); err != nil {
				return nil, err
			} else {
				ret[fmt.Sprintf("%d", team.Id)] = exportedTeam{
					team.Name,
					fmt.Sprintf("#%x", team.Color),
					rank[team.Id],
					points,
					members,
				}
			}
		}

		return ret, nil
	}
}

type uploadedTeam struct {
	Name  string
	Color int64
}

type uploadedMember struct {
	Firstname string
	Lastname  string
	Nickname  string
	Company   string
}

func listTeam(args []string, body []byte) (interface{}, error) {
	if len(args) >= 2 {
		if tid, err := strconv.Atoi(string(args[0])); err != nil {
			return nil, err
		} else if team, err := fic.GetTeam(tid); err != nil {
			return nil, err
		} else if args[1] == "my.json" {
			return myJSONTeam(team)
		} else if args[1] == "certificate" {
			return CertificateAPI(team, args[2:])
		}
	} else if len(args) == 1 {
		if args[0] == "teams.json" {
			return exportTeams()
		} else if args[0] == "nginx" {
			return nginxGenTeam()
		} else if tid, err := strconv.Atoi(string(args[0])); err != nil {
			return nil, err
		} else if team, err := fic.GetTeam(tid); err != nil {
			return nil, err
		} else {
			return team.GetMembers()
		}
	} else if len(args) == 0 {
		// List all teams
		return fic.GetTeams()
	}
	return nil, nil
}

func creationTeam(args []string, body []byte) (interface{}, error) {
	if len(args) == 1 {
		// List given team
		if tid, err := strconv.Atoi(string(args[0])); err != nil {
			return nil, err
		} else if team, err := fic.GetTeam(tid); err != nil {
			return nil, err
		} else {
			var members []uploadedMember
			if err := json.Unmarshal(body, &members); err != nil {
				return nil, err
			}

			for _, member := range members {
				team.AddMember(member.Firstname, member.Lastname, member.Nickname, member.Company)
			}

			return team.GetMembers()
		}
	} else if len(args) == 0 {
		// Create a new team
		var ut uploadedTeam
		if err := json.Unmarshal(body, &ut); err != nil {
			return nil, err
		}

		return fic.CreateTeam(ut.Name, ut.Color)
	} else {
		return nil, nil
	}
}

func creationTeamMembers(args []string, body []byte) (interface{}, error) {
	if len(args) == 1 {
		// List given team
		if tid, err := strconv.Atoi(string(args[0])); err != nil {
			return nil, err
		} else if team, err := fic.GetTeam(tid); err != nil {
			return nil, err
		} else {
			var member uploadedMember
			if err := json.Unmarshal(body, &member); err != nil {
				return nil, err
			}

			team.AddMember(member.Firstname, member.Lastname, member.Nickname, member.Company)

			return team.GetMembers()
		}
	} else if len(args) == 0 {
		// Create a new team
		var members []uploadedMember
		if err := json.Unmarshal(body, &members); err != nil {
			return nil, err
		}

		if team, err := fic.CreateTeam("", 0); err != nil {
			return nil, err
		} else {
			for _, member := range members {
				if _, err := team.AddMember(member.Firstname, member.Lastname, member.Nickname, member.Company); err != nil {
					return nil, err
				}
			}

			return team, nil
		}
	} else {
		return nil, nil
	}
}

func deletionTeam(args []string, body []byte) (interface{}, error) {
	if len(args) == 1 {
		if tid, err := strconv.Atoi(string(args[0])); err != nil {
			return nil, err
		} else if team, err := fic.GetTeam(tid); err != nil {
			return nil, err
		} else {
			return team.Delete()
		}
	} else {
		return nil, nil
	}
}