package main

import (
	"bytes"
	"encoding/base64"
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"sort"
	"strings"
	"text/template"

	camel "github.com/apache/camel-k/pkg/apis/camel/v1alpha1"
	"github.com/iancoleman/strcase"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/runtime/serializer"
	"k8s.io/apimachinery/pkg/util/yaml"
)

func main() {
	if len(os.Args) != 3 {
		println("usage: generator kamelets-path doc-root")
		os.Exit(1)
	}

	dir := os.Args[1]
	out := os.Args[2]

	funcMap := template.FuncMap{
		"ToCamel": strcase.ToCamel,
	}

	templateFile := path.Join(out, "kamelet.adoc.tmpl")
	t, err := template.New("kamelet.adoc.tmpl").Funcs(funcMap).ParseFiles(templateFile)
	handleGeneralError(fmt.Sprintf("cannot load template file from %s", templateFile), err)

	kamelets := listKamelets(dir)

	links := make([]string, 0)
	for _, k := range kamelets {
		img := saveImage(k, out)

		ctx := NewTemplateContext(k, img)

		buffer := new(bytes.Buffer)
		err = t.Execute(buffer, &ctx)
		handleGeneralError("cannot process template", err)

		produceDocFile(k, out, buffer.String())

		links = append(links, fmt.Sprintf("* xref:ROOT:%s.adoc[%s %s]", k.Name, img, k.Spec.Definition.Title))
	}

	saveNav(links, out)
}

type TemplateContext struct {
	Kamelet camel.Kamelet
	Image   string
}

func NewTemplateContext(kamelet camel.Kamelet, image string) TemplateContext {
	return TemplateContext{
		Kamelet: kamelet,
		Image:   image,
	}
}

type Prop struct {
	Name     string
	Title    string
	Required bool
	Default  *string
	Example  *string
}

func (p Prop) GetSampleValue() string {
	if p.Default != nil {
		return *p.Default
	}
	if p.Example != nil {
		return *p.Example
	}
	return fmt.Sprintf(`"The %s"`, p.Title)
}

func getSortedProps(k camel.Kamelet) []Prop {
	required := make(map[string]bool)
	props := make([]Prop, 0, len(k.Spec.Definition.Properties))
	for _, r := range k.Spec.Definition.Required {
		required[r] = true
	}
	for key := range k.Spec.Definition.Properties {
		prop := k.Spec.Definition.Properties[key]
		var def *string
		if prop.Default != nil {
			b, err := prop.Default.MarshalJSON()
			handleGeneralError(fmt.Sprintf("cannot marshal property %q default value in Kamelet %s", key, k.Name), err)
			defVal := string(b)
			def = &defVal
		}
		var ex *string
		if prop.Example != nil {
			b, err := prop.Example.MarshalJSON()
			handleGeneralError(fmt.Sprintf("cannot marshal property %q example value in Kamelet %s", key, k.Name), err)
			exVal := string(b)
			ex = &exVal
		}
		props = append(props, Prop{Name: key, Title: prop.Title, Required: required[key], Default: def, Example: ex})
	}
	sort.Slice(props, func(i, j int) bool {
		ri := props[i].Required
		rj := props[j].Required
		if ri && !rj {
			return true
		} else if !ri && rj {
			return false
		}
		return props[i].Name < props[j].Name
	})
	return props
}

func (ctx *TemplateContext) HasProperties() bool {
	return len(ctx.Kamelet.Spec.Definition.Properties) > 0
}

func (ctx *TemplateContext) Properties() string {
	content := ""
	if len(ctx.Kamelet.Spec.Definition.Properties) > 0 {
		props := getSortedProps(ctx.Kamelet)
		content += `[width="100%",cols="2,^2,3,^2,^2,^3",options="header"]` + "\n"
		content += "|===\n"
		content += tableLine("Property", "Name", "Description", "Type", "Default", "Example")

		for _, propDef := range props {
			key := propDef.Name
			prop := ctx.Kamelet.Spec.Definition.Properties[key]
			name := key
			if propDef.Required {
				name = "*" + name + " {empty}* *"
			}
			var def string
			if propDef.Default != nil {
				def = "`" + strings.ReplaceAll(*propDef.Default, "`", "'") + "`"
			}
			var ex string
			if propDef.Example != nil {
				ex = "`" + strings.ReplaceAll(*propDef.Example, "`", "'") + "`"
			}
			content += tableLine(name, prop.Title, prop.Description, prop.Type, def, ex)
		}

		content += "|===\n"

	}
	return content
}

func (ctx *TemplateContext) ExampleBinding(apiVersion, kind, name string) string {
	content := ""
	propDefs := getSortedProps(ctx.Kamelet)
	tp := ctx.Kamelet.ObjectMeta.Labels["camel.apache.org/kamelet.type"]
	if tp != "" {
		sampleConfig := make([]string, 0)
		for _, propDef := range propDefs {
			if !propDef.Required {
				continue
			}
			key := propDef.Name
			if propDef.Default == nil {
				ex := propDef.GetSampleValue()
				sampleConfig = append(sampleConfig, fmt.Sprintf("%s: %s", key, ex))
			}
		}
		props := ""
		if len(sampleConfig) > 0 {
			props += "    properties:\n"
			for _, p := range sampleConfig {
				props += fmt.Sprintf("      %s\n", p)
			}
		}

		kameletRef := fmt.Sprintf(`    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: %s
%s`, ctx.Kamelet.Name, props)

		boundToRef := fmt.Sprintf(`    ref:
      kind: %s
      apiVersion: %s
      name: %s
`, kind, apiVersion, name)
		var sourceRef string
		var sinkRef string
		var steps string

		switch tp {
		case "source":
			sourceRef = kameletRef
			sinkRef = boundToRef
		case "sink":
			sourceRef = boundToRef
			sinkRef = kameletRef
		case "action":
			sourceRef = `    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: timer-source
    properties:
      message: "Hello"`
			sinkRef = boundToRef
			steps = fmt.Sprintf(`
  steps:
  -%s`, kameletRef[3:])
		}

		binding := fmt.Sprintf(`apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: %s-binding
spec:
  source:
%s%s  sink:
%s
`, ctx.Kamelet.Name, sourceRef, steps, sinkRef)

		content += fmt.Sprintf(".%s-binding.yaml\n", ctx.Kamelet.Name)
		content += "[source,yaml]\n"
		content += "----\n"
		content += binding
		content += "----\n"

	}
	return content
}

func (ctx *TemplateContext) ExampleKamelBindCommand(ref string) string {
	tp := ctx.Kamelet.ObjectMeta.Labels["camel.apache.org/kamelet.type"]
	var prefix string
	switch tp {
	case "source":
		prefix = "source."
	case "sink":
		prefix = "sink."
	case "action":
		prefix = "step-0."
	default:
		handleGeneralError("unknown kamelet type", errors.New(tp))
	}

	cmd := "kamel bind "
	timer := "timer-source?message=Hello"
	kamelet := ctx.Kamelet.Name
	propDefs := getSortedProps(ctx.Kamelet)
	for _, p := range propDefs {
		if p.Required && p.Default == nil {
			val := p.GetSampleValue()
			if strings.HasPrefix(val, `"`) {
				kamelet += fmt.Sprintf(` -p "%s%s=%s`, prefix, p.Name, val[1:])
			} else {
				kamelet += fmt.Sprintf(" -p %s%s=%s", prefix, p.Name, val)
			}
		}
	}

	switch tp {
	case "source":
		return cmd + kamelet + " " + ref
	case "sink":
		return cmd + ref + " " + kamelet
	case "action":
		return cmd + timer + " --step " + kamelet + " " + ref
	default:
		handleGeneralError("unknown kamelet type", errors.New(tp))
	}
	return ""
}

func saveNav(links []string, out string) {
	content := "// THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT\n"
	for _, l := range links {
		content += l + "\n"
	}
	content += "// THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT\n"
	dest := filepath.Join(out, "nav.adoc")
	if _, err := os.Stat(dest); err == nil {
		err = os.Remove(dest)
		handleGeneralError(fmt.Sprintf("cannot remove file %q", dest), err)
	}
	err := ioutil.WriteFile(dest, []byte(content), 0666)
	handleGeneralError(fmt.Sprintf("cannot write file %q", dest), err)
	fmt.Printf("%q written\n", dest)
}

func saveImage(k camel.Kamelet, out string) string {
	if ic, ok := k.ObjectMeta.Annotations["camel.apache.org/kamelet.icon"]; ok {
		svgb64Prefix := "data:image/svg+xml;base64,"
		if strings.HasPrefix(ic, svgb64Prefix) {
			data := ic[len(svgb64Prefix):]
			decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
			iconContent, err := ioutil.ReadAll(decoder)
			handleGeneralError(fmt.Sprintf("cannot decode icon from Kamelet %s", k.Name), err)
			dest := filepath.Join(out, "assets", "images", "kamelets", fmt.Sprintf("%s.svg", k.Name))
			if _, err := os.Stat(dest); err == nil {
				err = os.Remove(dest)
				handleGeneralError(fmt.Sprintf("cannot remove file %q", dest), err)
			}
			err = ioutil.WriteFile(dest, iconContent, 0666)
			handleGeneralError(fmt.Sprintf("cannot write file %q", dest), err)
			fmt.Printf("%q written\n", dest)
			return fmt.Sprintf("image:kamelets/%s.svg[]", k.Name)
		}
	}
	return ""
}

func produceDocFile(k camel.Kamelet, out string, content string) {
	docFile := filepath.Join(out, "pages", k.Name+".adoc")
	if _, err := os.Stat(docFile); err == nil {
		err = os.Remove(docFile)
		handleGeneralError(fmt.Sprintf("cannot remove file %q", docFile), err)
	}
	err := ioutil.WriteFile(docFile, []byte(content), 0666)
	handleGeneralError(fmt.Sprintf("cannot write to file %q", docFile), err)
	fmt.Printf("%q written\n", docFile)
}

func tableLine(val ...string) string {
	res := ""
	for _, s := range val {
		clean := strings.ReplaceAll(s, "|", "\\|")
		res += "| " + clean
	}
	return res + "\n"
}

func listKamelets(dir string) []camel.Kamelet {
	scheme := runtime.NewScheme()
	err := camel.AddToScheme(scheme)
	handleGeneralError("cannot to add camel APIs to scheme", err)

	codecs := serializer.NewCodecFactory(scheme)
	gv := camel.SchemeGroupVersion
	gvk := schema.GroupVersionKind{
		Group:   gv.Group,
		Version: gv.Version,
		Kind:    "Kamelet",
	}
	decoder := codecs.UniversalDecoder(gv)

	kamelets := make([]camel.Kamelet, 0)
	files, err := ioutil.ReadDir(dir)
	filesSorted := make([]string, 0)
	handleGeneralError(fmt.Sprintf("cannot list dir %q", dir), err)
	for _, fd := range files {
		if !fd.IsDir() && strings.HasSuffix(fd.Name(), ".kamelet.yaml") {
			fullName := filepath.Join(dir, fd.Name())
			filesSorted = append(filesSorted, fullName)
		}
	}
	sort.Strings(filesSorted)
	for _, fileName := range filesSorted {
		content, err := ioutil.ReadFile(fileName)
		handleGeneralError(fmt.Sprintf("cannot read file %q", fileName), err)

		json, err := yaml.ToJSON(content)
		handleGeneralError(fmt.Sprintf("cannot convert file %q to JSON", fileName), err)

		kamelet := camel.Kamelet{}
		_, _, err = decoder.Decode(json, &gvk, &kamelet)
		handleGeneralError(fmt.Sprintf("cannot unmarshal file %q into Kamelet", fileName), err)
		kamelets = append(kamelets, kamelet)
	}
	return kamelets
}

func handleGeneralError(desc string, err error) {
	if err != nil {
		fmt.Printf("%s: %+v\n", desc, err)
		os.Exit(2)
	}
}