// Copyright © 2017 Mikael Berthe <mikael@lilotux.net>
//
// Licensed under the MIT license.
// Please see the LICENSE file is this directory.

package printer

import (
	"encoding/json"
	"fmt"
	"io"
	"os"
	"reflect"
	"strings"
	"text/template"
	"time"

	"github.com/kr/text"
	"github.com/mattn/go-isatty"

	"github.com/McKael/madon/v2"
	"github.com/McKael/madonctl/printer/colors"
)

// disableColors can be set to true to disable the color template function
var disableColors bool

// TemplatePrinter represents a Template printer
type TemplatePrinter struct {
	rawTemplate string
	template    *template.Template
}

// NewPrinterTemplate returns a Template ResourcePrinter
// For TemplatePrinter, the options parameter contains the template string.
// The "color_mode" option defines the color behaviour: it can be
// "auto" (default), "on" (forced), "off" (disabled).
func NewPrinterTemplate(options Options) (*TemplatePrinter, error) {
	tmpl := options["template"]
	if tmpl == "" {
		return nil, fmt.Errorf("empty template")
	}
	t, err := template.New("output").Funcs(template.FuncMap{
		"fromhtml": html2string,
		"fromunix": unix2time,
		"tolocal":  dateToLocal,
		"color":    ansiColor,
		"trim":     strings.TrimSpace,
		"wrap":     wrap,
	}).Parse(tmpl)
	if err != nil {
		return nil, err
	}

	// Update disableColors.
	// In auto-mode, check if stdout is a TTY.
	colorMode := options["color_mode"]
	if colorMode == "off" || (colorMode != "on" && !isatty.IsTerminal(os.Stdout.Fd())) {
		disableColors = true
	}

	return &TemplatePrinter{
		rawTemplate: tmpl,
		template:    t,
	}, nil
}

// PrintObj sends the object as text to the writer
// If the writer w is nil, standard output will be used.
func (p *TemplatePrinter) PrintObj(obj interface{}, w io.Writer, tmpl string) error {
	if w == nil {
		w = os.Stdout
	}

	if p.template == nil {
		return fmt.Errorf("template not built")
	}

	switch ot := obj.(type) { // I wish I knew a better way...
	case []madon.Account, []madon.Application, []madon.Attachment,
		[]madon.Card, []madon.Client, []madon.Context, []madon.Emoji,
		[]madon.Instance, []madon.List, []madon.Mention,
		[]madon.Notification, []madon.Relationship, []madon.Report,
		[]madon.Results, []madon.Status, []madon.StreamEvent,
		[]madon.Tag, []string:
		return p.templateForeach(ot, w)
	}

	return p.templatePrintSingleObj(obj, w)
}

func (p *TemplatePrinter) templatePrintSingleObj(obj interface{}, w io.Writer) error {
	if s, ok := obj.(string); ok {
		// obj is a simple string
		if err := p.safeExecute(w, s); err != nil {
			return fmt.Errorf("error executing template %q: %v", p.rawTemplate, err)
		}
		return nil
	}

	// This code comes from Kubernetes.
	data, err := json.Marshal(obj)
	if err != nil {
		return err
	}
	out := map[string]interface{}{}
	if err := json.Unmarshal(data, &out); err != nil {
		return err
	}
	if err = p.safeExecute(w, out); err != nil {
		return fmt.Errorf("error executing template %q: %v", p.rawTemplate, err)
	}
	return nil
}

// safeExecute tries to execute the template, but catches panics and returns an error
// should the template engine panic.
// This code comes from Kubernetes.
func (p *TemplatePrinter) safeExecute(w io.Writer, obj interface{}) error {
	var panicErr error
	// Sorry for the double anonymous function. There's probably a clever way
	// to do this that has the defer'd func setting the value to be returned, but
	// that would be even less obvious.
	retErr := func() error {
		defer func() {
			if x := recover(); x != nil {
				panicErr = fmt.Errorf("caught panic: %+v", x)
			}
		}()
		return p.template.Execute(w, obj)
	}()
	if panicErr != nil {
		return panicErr
	}
	return retErr
}

func (p *TemplatePrinter) templateForeach(ol interface{}, w io.Writer) error {
	switch reflect.TypeOf(ol).Kind() {
	case reflect.Slice:
		s := reflect.ValueOf(ol)

		for i := 0; i < s.Len(); i++ {
			o := s.Index(i).Interface()
			if err := p.templatePrintSingleObj(o, w); err != nil {
				return err
			}
		}
	}
	return nil
}

func ansiColor(desc string) (string, error) {
	if disableColors {
		return "", nil
	}
	return colors.ANSICodeString(desc)
}

// Parse datetime string from RFC3339 (default format in templates because
// of implicit conversion to string) and return a local time.
func dateToLocal(s string) (time.Time, error) {
	t, err := time.Parse(time.RFC3339, s)
	if err != nil {
		return t, err
	}
	return t.Local(), err
}

// Wrap text with indent prefix
func wrap(indent string, lineLength int, txt string) string {
	width := lineLength - len(indent)
	if width < 10 {
		width = 10
	}

	lines := strings.SplitAfter(txt, "\n")
	var out []string
	for _, l := range lines {
		l = strings.TrimLeft(l, " ")
		out = append(out, text.Indent(text.Wrap(l, width), indent))
	}
	return strings.Join(out, "\n")
}