package api

import (
	"encoding/json"
	"errors"
	"path"
	"reflect"

	"srs.epita.fr/fic-server/admin/sync"
	"srs.epita.fr/fic-server/libfic"
	"srs.epita.fr/fic-server/settings"

	"github.com/julienschmidt/httprouter"
)

var IsProductionEnv = false

func init() {
	router.GET("/api/settings-ro.json", apiHandler(getROSettings))
	router.GET("/api/settings.json", apiHandler(getSettings))
	router.PUT("/api/settings.json", apiHandler(saveSettings))
	router.DELETE("/api/settings.json", apiHandler(func(_ httprouter.Params, _ []byte) (interface{}, error) {
		return true, ResetSettings()
	}))

	router.POST("/api/reset", apiHandler(reset))
}

func getROSettings(_ httprouter.Params, body []byte) (interface{}, error) {
	syncMtd := "Disabled"
	if sync.GlobalImporter != nil {
		syncMtd = sync.GlobalImporter.Kind()
	}

	var syncId *string
	if sync.GlobalImporter != nil {
		syncId = sync.GlobalImporter.Id()
	}

	return map[string]interface{}{
		"sync-type": reflect.TypeOf(sync.GlobalImporter).Name(),
		"sync-id":   syncId,
		"sync":      syncMtd,
	}, nil
}

func getSettings(_ httprouter.Params, body []byte) (interface{}, error) {
	if s, err := settings.ReadSettings(path.Join(settings.SettingsDir, settings.SettingsFile)); err != nil {
		return nil, err
	} else {
		s.WorkInProgress = !IsProductionEnv
		return s, nil
	}
}

func saveSettings(_ httprouter.Params, body []byte) (interface{}, error) {
	var config settings.FICSettings
	if err := json.Unmarshal(body, &config); err != nil {
		return nil, err
	}

	if err := settings.SaveSettings(path.Join(settings.SettingsDir, settings.SettingsFile), config); err != nil {
		return nil, err
	} else {
		ApplySettings(config)
		return config, err
	}
}

func ApplySettings(config settings.FICSettings) {
	fic.PartialValidation = config.PartialValidation
	fic.UnlockedChallengeDepth = config.UnlockedChallengeDepth
	fic.DisplayAllFlags = config.DisplayAllFlags
	fic.DisplayMCQBadCount = config.DisplayMCQBadCount
	fic.FirstBlood = config.FirstBlood
	fic.SubmissionCostBase = config.SubmissionCostBase
	fic.HintCoefficient = config.HintCurCoefficient
	fic.WChoiceCoefficient = config.WChoiceCurCoefficient
	fic.GlobalScoreCoefficient = config.GlobalScoreCoefficient
	fic.SubmissionCostBase = config.SubmissionCostBase
	fic.SubmissionUniqueness = config.SubmissionUniqueness
	fic.CountOnlyNotGoodTries = config.CountOnlyNotGoodTries
}

func ResetSettings() error {
	return settings.SaveSettings(path.Join(settings.SettingsDir, settings.SettingsFile), settings.FICSettings{
		Title:                  "Challenge FIC",
		Authors:                "Laboratoire SRS, ÉPITA",
		WorkInProgress:         IsProductionEnv,
		FirstBlood:             fic.FirstBlood,
		SubmissionCostBase:     fic.SubmissionCostBase,
		ExerciceCurCoefficient: 1,
		HintCurCoefficient:     1,
		WChoiceCurCoefficient:  1,
		GlobalScoreCoefficient: 1,
		AllowRegistration:      false,
		CanJoinTeam:            false,
		DenyTeamCreation:       false,
		DenyNameChange:         false,
		AcceptNewIssue:         true,
		QAenabled:              false,
		EnableResolutionRoute:  false,
		PartialValidation:      true,
		UnlockedChallengeDepth: 0,
		SubmissionUniqueness:   false,
		DisplayAllFlags:        false,
		DisplayMCQBadCount:     false,
		EventKindness:          false,
	})
}

func reset(_ httprouter.Params, body []byte) (interface{}, error) {
	var m map[string]string
	if err := json.Unmarshal(body, &m); err != nil {
		return nil, err
	}

	if t, ok := m["type"]; !ok {
		return nil, errors.New("Field type not found")
	} else if t == "teams" {
		return true, fic.ResetTeams()
	} else if t == "challenges" {
		return true, fic.ResetExercices()
	} else if t == "game" {
		return true, fic.ResetGame()
	} else if t == "settings" {
		return true, ResetSettings()
	} else {
		return nil, errors.New("Unknown reset type")
	}
}