package sync

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

	"github.com/BurntSushi/toml"
	"github.com/julienschmidt/httprouter"
	"github.com/russross/blackfriday/v2"

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

// LogMissingResolution logs the absence of resolution.mp4 instead of returning an error.
var LogMissingResolution = false

func fixnbsp(s string) string {
	return strings.Replace(strings.Replace(strings.Replace(s, " ?", " ?", -1), " !", " !", -1), " :", " :", -1)
}

// 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 {
				if dir[0] != '.' && strings.Contains(dir, "-") {
					exercices = append(exercices, dir)
				}
			}
		}
	}

	return exercices, nil
}

func buildDependancyMap(i Importer, theme *fic.Theme) (dmap map[int64]*fic.Exercice, err error) {
	var exercices []string
	if exercices, err = GetExercices(i, theme); err != nil {
		return
	} else {
		dmap = map[int64]*fic.Exercice{}

		for _, edir := range exercices {
			var eid int
			var ename string
			eid, ename, err = parseExerciceDirname(edir)
			if err != nil {
				err = nil
				continue
			}

			var e *fic.Exercice
			e, err = theme.GetExerciceByTitle(ename)
			if err != nil {
				return
			}

			dmap[int64(eid)] = e
		}

		return
	}
}

func parseExerciceDirname(edir string) (eid int, ename string, err error) {
	edir_splt := strings.SplitN(edir, "-", 2)
	if len(edir_splt) != 2 {
		err = fmt.Errorf("%q is not a valid exercice directory: missing id prefix", edir)
		return
	}

	eid, err = strconv.Atoi(edir_splt[0])
	if err != nil {
		err = fmt.Errorf("%q: invalid exercice identifier: %s", edir, err)
		return
	}

	ename = edir_splt[1]

	return
}

// BuildExercice creates an Exercice from a given importer.
func BuildExercice(i Importer, theme *fic.Theme, epath string, dmap *map[int64]*fic.Exercice) (e *fic.Exercice, p ExerciceParams, eid int, edir string, errs []string) {
	e = &fic.Exercice{}

	e.Path = epath
	edir = path.Base(epath)

	var err error
	eid, e.Title, err = parseExerciceDirname(edir)
	if err != nil {
		errs = append(errs, fmt.Sprintf("%q: unable to parse exercice directory: %s", edir, err))
		return nil, p, eid, edir, errs
	}

	// Overwrite title if title.txt exists
	if myTitle, err := getFileContent(i, path.Join(epath, "title.txt")); err == nil {
		myTitle = strings.TrimSpace(myTitle)
		if strings.Contains(myTitle, "\n") {
			errs = append(errs, fmt.Sprintf("%q: title.txt: Title can't contain new lines", edir))
		} else {
			e.Title = myTitle
		}
	}

	e.URLId = fic.ToURLid(e.Title)
	e.Title = fixnbsp(e.Title)

	// Texts to format using Markdown
	e.Overview, err = getFileContent(i, path.Join(epath, "overview.txt"))
	if err != nil {
		errs = append(errs, fmt.Sprintf("%q: overview.txt: %s", edir, err))
	} else {
		e.Overview = fixnbsp(e.Overview)
		e.Headline = string(blackfriday.Run([]byte(strings.Split(e.Overview, "\n")[0])))
		if e.Overview, err = ProcessMarkdown(i, e.Overview, epath); err != nil {
			errs = append(errs, fmt.Sprintf("%q: overview.txt: an error occurs during markdown formating: %s", edir, err))
		}
	}

	e.Statement, err = getFileContent(i, path.Join(epath, "statement.txt"))
	if err != nil {
		errs = append(errs, fmt.Sprintf("%q: statement.txt: %s", edir, err))
	} else {
		if e.Statement, err = ProcessMarkdown(i, fixnbsp(e.Statement), epath); err != nil {
			errs = append(errs, fmt.Sprintf("%q: statement.txt: an error occurs during markdown formating: %s", edir, err))
		}
	}

	if i.exists(path.Join(epath, "finished.txt")) {
		e.Finished, err = getFileContent(i, path.Join(epath, "finished.txt"))
		if err != nil {
			errs = append(errs, fmt.Sprintf("%q: finished.txt: %s", edir, err))
		} else {
			if e.Finished, err = ProcessMarkdown(i, e.Finished, epath); err != nil {
				errs = append(errs, fmt.Sprintf("%q: finished.txt: an error occurs during markdown formating: %s", edir, err))
			}
		}
	}

	// Parse challenge.txt
	var md toml.MetaData
	p, md, err = parseExerciceParams(i, epath)
	if err != nil {
		errs = append(errs, fmt.Sprintf("%q: %s", edir, err))
		return
	}

	// Alert about unknown keys in challenge.txt
	if len(md.Undecoded()) > 0 {
		for _, k := range md.Undecoded() {
			errs = append(errs, fmt.Sprintf("%q: challenge.txt: unknown key %q found, check https://srs.nemunai.re/fic/files/challenge/", edir, k))
		}
	}

	if p.Gain == 0 {
		errs = append(errs, fmt.Sprintf("%q: challenge.txt: Undefined gain for challenge", edir))
	} else {
		e.Gain = p.Gain
	}

	// 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 (%q): not implemented.", edir, p.Dependencies[0].Theme))
		} else {
			if dmap == nil {
				if dmap2, err := buildDependancyMap(i, theme); err != nil {
					errs = append(errs, fmt.Sprintf("%q: unable to build dependency map: %s", edir, err))
				} else {
					dmap = &dmap2
				}
			}

			if dmap != nil {
				for edk, ed := range *dmap {
					if edk == p.Dependencies[0].Id {
						e.Depend = &ed.Id
						break
					}
				}
				if e.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 exercice dependancy %d (available at time of processing: %s)", edir, p.Dependencies[0].Id, strings.Join(dmap_keys, ",")))
				}
			}
		}
	}

	// Handle resolutions
	resolutionFound := false

	e.VideoURI = path.Join(epath, "resolution.mp4")
	if !i.exists(e.VideoURI) {
		e.VideoURI = ""
	} else if size, err := getFileSize(i, e.VideoURI); err != nil {
		errs = append(errs, fmt.Sprintf("%q: resolution.mp4: ", edir, err))
		e.VideoURI = ""
	} else if size == 0 {
		errs = append(errs, fmt.Sprintf("%q: resolution.mp4: The file is empty!", edir))
		e.VideoURI = ""
	} else {
		resolutionFound = true
	}

	writeup := path.Join(epath, "resolution.md")
	if !i.exists(writeup) {
		writeup = path.Join(epath, "resolution.txt")
	}

	if i.exists(writeup) {
		if size, err := getFileSize(i, writeup); err != nil {
			errs = append(errs, fmt.Sprintf("%q: resolution.md: %s", edir, err.Error()))
		} else if size == 0 {
			errs = append(errs, fmt.Sprintf("%q: resolution.md: The file is empty!", edir))
		} else if e.Resolution, err = getFileContent(i, writeup); err != nil {
			errs = append(errs, fmt.Sprintf("%q: resolution.md: %s", edir, err.Error()))
		} else if e.Resolution, err = ProcessMarkdown(i, e.Overview, epath); err != nil {
			errs = append(errs, fmt.Sprintf("%q: resolution.md: error during markdown processing: %s", edir, err.Error()))
		} else {
			resolutionFound = true
		}
	}

	if !resolutionFound {
		if LogMissingResolution {
			log.Printf("%q: no resolution video or text file found in %s", edir, epath, epath)
		} else {
			errs = append(errs, fmt.Sprintf("%q: no resolution video or text file found in %s", edir, epath))
		}
	}

	return
}

// SyncExercice imports new or updates existing given exercice.
func SyncExercice(i Importer, theme *fic.Theme, epath string, dmap *map[int64]*fic.Exercice) (e *fic.Exercice, eid int, errs []string) {
	var err error
	var edir string
	var p ExerciceParams

	e, p, eid, edir, errs = BuildExercice(i, theme, epath, dmap)

	if e != nil {
		// Create or update the exercice
		err = theme.SaveNamedExercice(e)
		if err != nil {
			errs = append(errs, fmt.Sprintf("%q: error on exercice save: %s", edir, err))
			return
		}

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

	return
}

// SyncExercices imports new or updates existing exercices, in a given theme.
func SyncExercices(i Importer, theme *fic.Theme) (errs []string) {
	if exercices, err := GetExercices(i, theme); err != nil {
		errs = append(errs, err.Error())
	} else {
		emap := map[string]int{}

		dmap, _ := buildDependancyMap(i, theme)

		for _, edir := range exercices {
			e, eid, cur_errs := SyncExercice(i, theme, path.Join(theme.Path, edir), &dmap)
			if e != nil {
				emap[e.Title] = eid
				dmap[int64(eid)] = e
				errs = append(errs, cur_errs...)
			}
		}

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

// ApiListRemoteExercices is an accessor letting foreign packages to access remote exercices list.
func ApiListRemoteExercices(ps httprouter.Params, _ []byte) (interface{}, error) {
	theme, errs := BuildTheme(GlobalImporter, ps.ByName("thid"))
	if theme != nil {
		return GetExercices(GlobalImporter, theme)
	} else {
		return nil, fmt.Errorf("%q", errs)
	}
}

// ApiListRemoteExercice is an accessor letting foreign packages to access remote exercice attributes.
func ApiGetRemoteExercice(ps httprouter.Params, _ []byte) (interface{}, error) {
	theme, errs := BuildTheme(GlobalImporter, ps.ByName("thid"))
	if theme != nil {
		exercice, _, _, _, errs := BuildExercice(GlobalImporter, theme, path.Join(theme.Path, ps.ByName("exid")), nil)
		if exercice != nil {
			return exercice, nil
		} else {
			return exercice, fmt.Errorf("%q", errs)
		}
	} else {
		return nil, fmt.Errorf("%q", errs)
	}
}