package sync

import (
	"fmt"
	"path"
	"strings"
	"strconv"

	"srs.epita.fr/fic-server/libfic"
	"gopkg.in/russross/blackfriday.v2"
)

// getExercices returns all exercice directories existing in a given theme, considering the given Importer.
func getExercices(i Importer, theme fic.Theme) ([]string, error) {
	var exercices []string

	if len(theme.Path) == 0 {
		return []string{}, nil
	} else if dirs, err := i.listDir(theme.Path); err != nil {
		return []string{}, err
	} else {
		for _, dir := range dirs {
			if _, err := i.listDir(path.Join(theme.Path, dir)); err == nil {
				exercices = append(exercices, dir)
			}
		}
	}

	return exercices, nil
}

// SyncExercices imports new or updates existing exercices, in a given theme.
func SyncExercices(i Importer, theme fic.Theme) []string {
	var errs []string

	if exercices, err := getExercices(i, theme); err != nil {
		errs = append(errs, err.Error())
	} else {
		dmap := map[int64]fic.Exercice{}
		emap := map[string]int{}
		for _, edir := range exercices {
			edir_splt := strings.SplitN(edir, "-", 2)
			if len(edir_splt) != 2 {
				errs = append(errs, fmt.Sprintf("%q is not a valid exercice directory: missing id prefix", edir))
				continue
			}

			eid, err := strconv.Atoi(edir_splt[0])
			if err != nil {
				errs = append(errs, fmt.Sprintf("%q: invalid exercice identifier: %s", edir, err))
				continue
			}
			ename := edir_splt[1]

			emap[ename] = eid

			// Overview and scenario
			overview, err := getFileContent(i, path.Join(theme.Path, edir, "overview.txt"))
			if err != nil {
				errs = append(errs, fmt.Sprintf("%q: overview.txt: %s", edir, err))
			}
			ovrvw := strings.Split(overview, "\n")
			headline := ovrvw[0]
			if len(ovrvw) > 1 {
				overview = strings.Join(ovrvw[1:], "\n")
			}

			statement, err := getFileContent(i, path.Join(theme.Path, edir, "statement.txt"))
			if err != nil {
				errs = append(errs, fmt.Sprintf("%q: statement.txt: %s", edir, err))
				continue
			}

			var finished string
			if i.exists(path.Join(theme.Path, edir, "finished.txt")) {
				finished, err = getFileContent(i, path.Join(theme.Path, edir, "finished.txt"))
				if err != nil {
					errs = append(errs, fmt.Sprintf("%q: statement.txt: %s", edir, err))
					continue
				}
			}

			// Handle score gain
			var gain int64
			var depend *fic.Exercice
			var tags []string
			if p, err := parseExerciceParams(i, path.Join(theme.Path, edir)); err != nil {
				errs = append(errs, fmt.Sprintf("%q: challenge.txt: %s", edir, err))
				continue
			} else if p.Gain == 0 {
				errs = append(errs, fmt.Sprintf("%q: challenge.txt: Undefined gain for challenge", edir))
			} else {
				gain = p.Gain
				tags = p.Tags

				// Handle dependency
				if len(p.Dependencies) > 0 {
					if len(p.Dependencies[0].Theme) > 0 && p.Dependencies[0].Theme != theme.Name {
						errs = append(errs, fmt.Sprintf("%q: unable to treat dependency to another theme: not implemented.", edir))
					} else {
						for ed, e := range dmap {
							if ed == p.Dependencies[0].Id {
								depend = &e
								break
							}
						}
						if depend == nil {
							dmap_keys := []string{}
							for k, _ := range dmap {
								dmap_keys = append(dmap_keys, fmt.Sprintf("%d", k))
							}
							errs = append(errs, fmt.Sprintf("%q: Unable to find required dependancy %q (available at time of processing: %s)", edir, p.Dependencies[0].Id, strings.Join(dmap_keys, ",")))
						}
					}
				}
			}

			// Handle video
			videoURI := path.Join(theme.Path, edir, "resolution.mp4")
			if !i.exists(videoURI) {
				errs = append(errs, fmt.Sprintf("%q: resolution.mp4: no video file found at %s", edir, videoURI))
				videoURI = ""
			}

			// Markdown pre-formating
			statement = ProcessMarkdown(i, statement, edir)
			overview = ProcessMarkdown(i, overview, edir)
			headline = string(blackfriday.Run([]byte(headline)))
			finished = ProcessMarkdown(i, finished, edir)

			e, err := theme.GetExerciceByTitle(ename)
			if err != nil {
				if e, err = theme.AddExercice(ename, fic.ToURLid(ename), path.Join(theme.Path, edir), statement, overview, headline, depend, gain, videoURI, finished); err != nil {
					errs = append(errs, fmt.Sprintf("%q: error on exercice add: %s", edir, err))
					continue
				}
			} else if e.Title != ename || e.URLId == "" || e.Statement != statement || e.Overview != overview || e.Headline != headline || e.Gain != gain || e.VideoURI != videoURI || e.Finished != finished {
				e.Title = ename
				e.URLId = fic.ToURLid(ename)
				e.Statement = statement
				e.Overview = overview
				e.Headline = headline
				e.Finished = finished
				e.Gain = gain
				e.VideoURI = videoURI
				if _, err := e.Update(); err != nil {
					errs = append(errs, fmt.Sprintf("%q: error on exercice update: %s", edir, err))
					continue
				}
			}
			dmap[int64(eid)] = e

			if _, err := e.WipeTags(); err != nil {
				errs = append(errs, fmt.Sprintf("%q: Unable to wipe tags: %s", edir, err))
			}
			for _, tag := range tags {
				if _, err := e.AddTag(tag); err != nil {
					errs = append(errs, fmt.Sprintf("%q: Unable to add tag: %s", edir, err))
					continue
				}
			}
		}

		// Remove old exercices
		if exercices, err := theme.GetExercices(); err == nil {
			for _, ex := range exercices {
				if _, ok := emap[ex.Title]; !ok {
					ex.Delete()
				}
			}
		}
	}
	return errs
}

// ApiListRemoteExercices is an accessor letting foreign packages to access remote exercices list.
func ApiListRemoteExercices(theme fic.Theme, _ []byte) (interface{}, error) {
	return getExercices(GlobalImporter, theme)
}