package renderer

import (
	"fmt"
	"html/template"
	"io/ioutil"
	"net/url"
	"os"
	"reflect"
	"strconv"
	"strings"
	"time"

	"git.andreafazzi.eu/andrea/oef/errors"
	"git.andreafazzi.eu/andrea/oef/i18n"

	"github.com/dchest/captcha"
	jwt "github.com/dgrijalva/jwt-go"
	"github.com/jinzhu/inflection"
	yml "gopkg.in/yaml.v2"

	"github.com/microcosm-cc/bluemonday"
	"gopkg.in/russross/blackfriday.v2"
)

const (
	MaxTextLength = 20
)

var (
	funcMap = template.FuncMap{
		"env":            env,
		"genCaptcha":     genCaptcha,
		"markdown":       markdown,
		"version":        version,
		"toInt":          toInt,
		"isResponseIn":   isResponseIn,
		"query":          query,
		"convertDate":    convertDate,
		"convertTime":    convertTime,
		"prettyDate":     prettyDate,
		"prettyTime":     prettyTime,
		"prettyDateTime": prettyDateTime,
		"zeroTime":       zeroTime,
		"seconds":        seconds,
		"modelPath":      modelPath,
		"dict":           dict,
		"yaml":           yaml,
		"create":         create,
		"update":         update,
		"delete":         delete,
		"show":           show,
		"all":            all,
		"execute":        execute,
		"isSlice":        isSlice,
		"toSlice":        toSlice,
		"string":         callString,
		"incr":           incr,
		"mod2":           mod2,
		"toLower":        toLower,
		"anchor":         anchor,
		"alertLink":      alertLink,
		"html":           html,
		"field":          field,
		"modelName":      modelName,
		"active":         active,
		"pluralize":      pluralize,
		"lower":          lower,
		"trim":           trim,
		"username":       username,
		"isAdmin":        isAdmin,
		"isSchool":       isSchool,
		"modelId":        modelId,
		"isParticipant":  isParticipant,
		"isSubscriber":   isSubscriber,
		"attr":           attr,
	}
)

func env(key string) string {
	return os.Getenv(key)
}

func genCaptcha() string {
	return captcha.New()
}

func markdown(text string) string {
	sanitized := strings.Replace(text, "\r\n", "\n", -1)
	unsafe := blackfriday.Run([]byte(sanitized))
	return string(bluemonday.UGCPolicy().SanitizeBytes(unsafe))
}
func version() string {
	version, err := ioutil.ReadFile("./VERSION")
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(version))
}

func toInt(value float64) int {
	return int(value)
}

func isResponseIn(id uint, answersIDs string) (bool, error) {
	if answersIDs != "" {
		ids := make([]uint, 0)
		srIDs := strings.Split(answersIDs, " ")
		for _, srID := range srIDs {
			id, err := strconv.Atoi(srID)
			if err != nil {
				return false, err
			}
			ids = append(ids, uint(id))
		}

		for _, v := range ids {
			if v == id {
				return true, nil
			}
		}
	}
	return false, nil
}

func username(claims jwt.MapClaims) string {
	return claims["username"].(string)
}

func modelId(claims jwt.MapClaims) (uint, error) {
	id, err := strconv.Atoi(claims["model_id"].(string))
	if err != nil {
		return 0, err
	}
	return uint(id), nil
}

func getRole(claims jwt.MapClaims) (string, error) {
	role, ok := claims["role"]
	if !ok {
		return "", errors.NotAuthorized
	}
	return role.(string), nil
}

func isAdmin(claims jwt.MapClaims) (bool, error) {
	role, err := getRole(claims)
	if err != nil {
		return false, err
	}
	return role == "administrator", nil
}

func isParticipant(claims jwt.MapClaims) (bool, error) {
	role, err := getRole(claims)
	if err != nil {
		return false, err
	}

	return role == "participant", nil
}

func isSchool(claims jwt.MapClaims) (bool, error) {
	role, err := getRole(claims)
	if err != nil {
		return false, err
	}

	return role == "school", nil
}

func isSubscriber(claims jwt.MapClaims) (bool, error) {
	role, err := getRole(claims)
	if err != nil {
		return false, err
	}

	return role == "subscriber", nil
}

func trim(text string) string {
	if len(text) > MaxTextLength {
		return text[0:MaxTextLength] + "…"
	}
	return text
}

func modelName(value interface{}) string {
	t := reflect.TypeOf(value)
	switch t.Kind() {
	case reflect.Ptr:
		return t.Elem().Name()
	case reflect.Slice:
		return strings.Replace(t.Elem().String(), "*orm.", "", -1)
	default:
		return t.Name()
	}
}

func lower(text string) string {
	return strings.ToLower(text)
}

func pluralize(text string) string {
	return inflection.Plural(text)
}

func active(value string, options url.Values) string {
	if len(options["tpl_content"]) > 0 {
		model := strings.Title(inflection.Singular(strings.Split(options["tpl_content"][0], "_")[0]))
		if value == model {
			return "active"
		}
	}
	return ""
}
func field(name string, value interface{}) interface{} {
	if value != nil {
		s := reflect.ValueOf(value).Elem()
		return s.FieldByName(name).Interface()
	} else {
		return nil
	}
}

func html(content string) template.HTML {
	return template.HTML(content)
}

func attr(attr string) template.HTMLAttr {
	return template.HTMLAttr(attr)
}

func anchor(text, url string) template.HTML {
	return template.HTML(fmt.Sprintf("<a href=\"%s\">%s</a>", url, text))
}

func alertLink(text, url string) template.HTML {
	return template.HTML(fmt.Sprintf("<a class=\"alert-link\" href=\"%s\">%s</a>", url, text))
}

func toLower(text string) string {
	return strings.ToLower(text)
}

func mod2(value int) bool {
	return value%2 == 0
}

func incr(value int) int {
	return value + 1
}

func callString(value interface{}) string {
	if value != nil {
		switch reflect.ValueOf(value).Kind() {
		case reflect.String:
			return value.(string)
		case reflect.Bool:
			if value.(bool) {
				return i18n.Text["answerCorrect"]["it"]
			}
			return "false"
		default:
			return reflect.ValueOf(value).MethodByName("String").Interface().(func() string)()
		}
	} else {
		return ""
	}
}

func isSlice(value interface{}) bool {
	return reflect.TypeOf(value).Kind() == reflect.Slice
}

func yaml(content string) (interface{}, error) {
	var result interface{}
	err := yml.Unmarshal([]byte(content), &result)
	if err != nil {
		return nil, err
	}
	return result, nil
}

func dict(values ...interface{}) (map[string]interface{}, error) {
	if len(values)%2 != 0 {
		return nil, fmt.Errorf("Invalid dict call, numbers of arguments is %d but should be a multiple of two", len(values))
	}
	dict := make(map[string]interface{}, len(values)/2)
	for i := 0; i < len(values); i += 2 {
		key, ok := values[i].(string)
		if !ok {
			return nil, fmt.Errorf("%s", "dict keys must be strings")
		}
		dict[key] = values[i+1]
	}
	return dict, nil
}

func toSlice(values ...string) interface{} {
	var result []string
	result = append(result, values...)
	return result
}

func getType(myvar interface{}) (res string) {
	t := reflect.TypeOf(myvar)
	for t.Kind() == reflect.Ptr {
		t = t.Elem()
		res += "*"
	}
	return res + t.Name()
}

func query(values ...string) template.URL {
	var (
		urlValues url.Values
		format    bool
	)

	urlValues = make(url.Values)

	for i := 0; i < len(values); i += 2 {
		if values[i] == "format" {
			format = true
		}
		urlValues.Add(values[i], values[i+1])
	}

	if !format {
		urlValues.Set("format", "html")
	}

	return template.URL(urlValues.Encode())
}

func convertDate(value interface{}) string {
	t, ok := value.(time.Time)
	if !ok {
		return ""
	}
	return fmt.Sprintf("%d-%02d-%02d", t.Year(), t.Month(), t.Day())
}

func prettyDate(value interface{}) string {
	t, ok := value.(time.Time)
	if !ok {
		return ""
	}
	if zeroTime(&t) {
		return i18n.Text["alwaysActiveContest"]["it"]
	}

	return fmt.Sprintf("%02d/%02d/%d", t.Day(), t.Month(), t.Year())
}

func prettyDateTime(value interface{}) string {
	t, ok := value.(time.Time)
	if !ok {
		return ""
	}
	return fmt.Sprintf(i18n.Formats["dateTime"]["it"], t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute())
}

func convertTime(value interface{}) string {
	t, ok := value.(time.Time)
	if !ok {
		return ""
	}
	return fmt.Sprintf("%02d:%02d", t.Hour(), t.Minute())
}

func prettyTime(value interface{}) string {
	return convertTime(value)
}

func zeroTime(t *time.Time) bool {
	return *t == time.Time{}
}

func seconds(d time.Duration) int {
	return int(d.Seconds())
}

func modelPath(model string, action string, id uint) string {
	var q template.URL

	action = strings.ToLower(action)
	plural := inflection.Plural(strings.ToLower(model))

	if action != "" {
		switch action {
		case "show":
			q = query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_%s", plural, action))
			return fmt.Sprintf("/%s/%d?%s", plural, id, q)
		case "update":
			q = query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_add_update", plural), "update", "true")
			return fmt.Sprintf("/%s/%d/%s?%s", plural, id, action, q)
		case "create":
			q = query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_add_update", plural))
			return fmt.Sprintf("/%s/%s/?%s", plural, action, q)
		case "delete":
			q = query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_%s", plural, action))
			return fmt.Sprintf("/%s/%d/%s?%s", plural, id, action, q)
		}
	}
	q = query("tpl_layout", "base", "tpl_content", plural)
	return fmt.Sprintf("/%s?%s", plural, q)
}

func all(model string) string {
	plural := inflection.Plural(strings.ToLower(model))
	q := query("tpl_layout", "base", "tpl_content", plural)

	return fmt.Sprintf("/%s?%s", plural, q)
}

func create(model string) string {
	action := "create"
	plural := inflection.Plural(strings.ToLower(model))
	q := query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_add_update", plural))

	return fmt.Sprintf("/%s/%s/?%s", plural, action, q)
}

func show(model string, id uint, format ...string) string {
	action := "show"
	plural := inflection.Plural(strings.ToLower(model))

	args := []string{"tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_%s", plural, action)}

	if len(format) > 0 {
		args = append(args, []string{"format", format[0]}...)
	}

	// q := query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_%s", plural, action))
	q := query(args...)

	return fmt.Sprintf("/%s/%d?%s", plural, id, q)
}

func execute(model string, id uint) string {
	action := "execute"
	plural := inflection.Plural(strings.ToLower(model))
	q := query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_%s", plural, action))

	return fmt.Sprintf("/%s/%d/%s?%s", plural, id, action, q)
}

func update(model string, id uint) string {
	action := "update"
	plural := inflection.Plural(strings.ToLower(model))
	q := query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_add_update", plural), "update", "true")

	return fmt.Sprintf("/%s/%d/%s?%s", plural, id, action, q)
}

func delete(model string, id uint) string {
	action := "delete"
	plural := inflection.Plural(strings.ToLower(model))
	q := query("tpl_layout", "base", "tpl_content", fmt.Sprintf("%s_%s", plural, action))

	return fmt.Sprintf("/%s/%d/%s?%s", plural, id, action, q)
}