package main

import (
	"bytes"
	"fmt"
	"go/format"
	"io/ioutil"
	"path/filepath"
	"runtime"
	"strings"
	"text/template"
)

type opType struct {
	Op                    string
	Code                  string
	Indent                func() string
	Escaped               func() string
	HeadToPtrHead         func() string
	HeadToNPtrHead        func() string
	HeadToAnonymousHead   func() string
	HeadToOmitEmptyHead   func() string
	HeadToStringTagHead   func() string
	PtrHeadToHead         func() string
	FieldToEnd            func() string
	FieldToOmitEmptyField func() string
	FieldToStringTagField func() string
}

func (t opType) IsEscaped() bool {
	return t.Op != t.Escaped()
}

func (t opType) IsHeadToPtrHead() bool {
	return t.Op != t.HeadToPtrHead()
}

func (t opType) IsHeadToNPtrHead() bool {
	return t.Op != t.HeadToNPtrHead()
}

func (t opType) IsHeadToAnonymousHead() bool {
	return t.Op != t.HeadToAnonymousHead()
}

func (t opType) IsHeadToOmitEmptyHead() bool {
	return t.Op != t.HeadToOmitEmptyHead()
}

func (t opType) IsHeadToStringTagHead() bool {
	return t.Op != t.HeadToStringTagHead()
}

func (t opType) IsPtrHeadToHead() bool {
	return t.Op != t.PtrHeadToHead()
}

func (t opType) IsFieldToEnd() bool {
	return t.Op != t.FieldToEnd()
}

func (t opType) IsFieldToOmitEmptyField() bool {
	return t.Op != t.FieldToOmitEmptyField()
}

func (t opType) IsFieldToStringTagField() bool {
	return t.Op != t.FieldToStringTagField()
}

func createOpType(op, code string) opType {
	return opType{
		Op:                    op,
		Code:                  code,
		Indent:                func() string { return fmt.Sprintf("%sIndent", op) },
		Escaped:               func() string { return op },
		HeadToPtrHead:         func() string { return op },
		HeadToNPtrHead:        func() string { return op },
		HeadToAnonymousHead:   func() string { return op },
		HeadToOmitEmptyHead:   func() string { return op },
		HeadToStringTagHead:   func() string { return op },
		PtrHeadToHead:         func() string { return op },
		FieldToEnd:            func() string { return op },
		FieldToOmitEmptyField: func() string { return op },
		FieldToStringTagField: func() string { return op },
	}
}

func _main() error {
	tmpl, err := template.New("").Parse(`// Code generated by cmd/generator. DO NOT EDIT!
package json

type codeType int

const (
{{- range $index, $type := .CodeTypes }}
  code{{ $type }} codeType = {{ $index }}
{{- end }}
)

type opType int

const (
{{- range $index, $type := .OpTypes }}
  op{{ $type.Op }} opType = {{ $index }}
{{- end }}
)

func (t opType) String() string {
  if int(t) >= {{ .OpLen }} {
    return t.toNotIndent().String() + "Indent"
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
  case op{{ $type.Op }}:
    return "{{ $type.Op }}"
{{- end }}
  }
  return ""
}

func (t opType) codeType() codeType {
  if int(t) >= {{ .OpLen }} {
    return t.toNotIndent().codeType()
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
  case op{{ $type.Op }}:
    return code{{ $type.Code }}
{{- end }}
  }
  return codeOp
}

func (t opType) toNotIndent() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t) - {{ .OpLen }})
  }
  return t
}

func (t opType) toIndent() opType {
  if int(t) >= {{ .OpLen }} {
    return t
  }
  return opType(int(t) + {{ .OpLen }})
}

func (t opType) toEscaped() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().toEscaped()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsEscaped }}
  case op{{ $type.Op }}:
    return op{{ call $type.Escaped }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) headToPtrHead() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().headToPtrHead()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsHeadToPtrHead }}
  case op{{ $type.Op }}:
    return op{{ call $type.HeadToPtrHead }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) headToNPtrHead() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().headToNPtrHead()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsHeadToNPtrHead }}
  case op{{ $type.Op }}:
    return op{{ call $type.HeadToNPtrHead }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) headToAnonymousHead() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().headToAnonymousHead()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsHeadToAnonymousHead }}
  case op{{ $type.Op }}:
    return op{{ call $type.HeadToAnonymousHead }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) headToOmitEmptyHead() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().headToOmitEmptyHead()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsHeadToOmitEmptyHead }}
  case op{{ $type.Op }}:
    return op{{ call $type.HeadToOmitEmptyHead }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) headToStringTagHead() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().headToStringTagHead()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsHeadToStringTagHead }}
  case op{{ $type.Op }}:
    return op{{ call $type.HeadToStringTagHead }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) ptrHeadToHead() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().ptrHeadToHead()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsPtrHeadToHead }}
  case op{{ $type.Op }}:
    return op{{ call $type.PtrHeadToHead }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) fieldToEnd() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().fieldToEnd()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsFieldToEnd }}
  case op{{ $type.Op }}:
    return op{{ call $type.FieldToEnd }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) fieldToOmitEmptyField() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().fieldToOmitEmptyField()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsFieldToOmitEmptyField }}
  case op{{ $type.Op }}:
    return op{{ call $type.FieldToOmitEmptyField }}
{{- end }}
{{- end }}
  }
  return t
}

func (t opType) fieldToStringTagField() opType {
  if int(t) >= {{ .OpLen }} {
    return opType(int(t.toNotIndent().fieldToStringTagField()) + {{ .OpLen }})
  }

  switch t {
{{- range $type := .OpNotIndentTypes }}
{{- if $type.IsFieldToStringTagField }}
  case op{{ $type.Op }}:
    return op{{ call $type.FieldToStringTagField }}
{{- end }}
{{- end }}
  }
  return t
}

`)
	if err != nil {
		return err
	}
	codeTypes := []string{
		"Op",
		"ArrayHead",
		"ArrayElem",
		"SliceHead",
		"SliceElem",
		"MapHead",
		"MapKey",
		"MapValue",
		"MapEnd",
		"StructFieldRecursive",
		"StructField",
		"StructEnd",
	}
	primitiveTypes := []string{
		"int", "int8", "int16", "int32", "int64",
		"uint", "uint8", "uint16", "uint32", "uint64",
		"float32", "float64", "bool", "string", "escapedString", "bytes",
		"array", "map", "mapLoad", "slice", "struct", "MarshalJSON", "MarshalText", "recursive",
		"intString", "int8String", "int16String", "int32String", "int64String",
		"uintString", "uint8String", "uint16String", "uint32String", "uint64String",
		"intPtr", "int8Ptr", "int16Ptr", "int32Ptr", "int64Ptr",
		"uintPtr", "uint8Ptr", "uint16Ptr", "uint32Ptr", "uint64Ptr",
		"float32Ptr", "float64Ptr", "boolPtr", "stringPtr", "escapedStringPtr", "bytesPtr",
		"intNPtr", "int8NPtr", "int16NPtr", "int32NPtr", "int64NPtr",
		"uintNPtr", "uint8NPtr", "uint16NPtr", "uint32NPtr", "uint64NPtr",
		"float32NPtr", "float64NPtr", "boolNPtr", "stringNPtr", "escapedStringNPtr", "bytesNPtr",
	}
	primitiveTypesUpper := []string{}
	for _, typ := range primitiveTypes {
		primitiveTypesUpper = append(primitiveTypesUpper, strings.ToUpper(string(typ[0]))+typ[1:])
	}
	opTypes := []opType{
		createOpType("End", "Op"),
		createOpType("Interface", "Op"),
		createOpType("InterfaceEnd", "Op"),
		createOpType("Ptr", "Op"),
		createOpType("NPtr", "Op"),
		createOpType("SliceHead", "SliceHead"),
		createOpType("RootSliceHead", "SliceHead"),
		createOpType("SliceElem", "SliceElem"),
		createOpType("RootSliceElem", "SliceElem"),
		createOpType("SliceEnd", "Op"),
		createOpType("ArrayHead", "ArrayHead"),
		createOpType("ArrayElem", "ArrayElem"),
		createOpType("ArrayEnd", "Op"),
		createOpType("MapHead", "MapHead"),
		createOpType("MapHeadLoad", "MapHead"),
		createOpType("MapKey", "MapKey"),
		createOpType("MapValue", "MapValue"),
		createOpType("MapEnd", "Op"),
		createOpType("StructFieldRecursiveEnd", "Op"),
		createOpType("StructAnonymousEnd", "StructEnd"),
	}
	for _, typ := range primitiveTypesUpper {
		typ := typ
		optype := createOpType(typ, "Op")
		switch typ {
		case "String", "StringPtr", "StringNPtr":
			optype.Escaped = func() string {
				return fmt.Sprintf("Escaped%s", typ)
			}
		}
		opTypes = append(opTypes, optype)
	}
	for _, escapedOrNot := range []string{"", "Escaped"} {
		for _, ptrOrNot := range []string{"", "Ptr", "NPtr"} {
			for _, headType := range []string{"", "Anonymous"} {
				for _, opt := range []string{"", "OmitEmpty", "StringTag"} {
					for _, typ := range append(primitiveTypesUpper, "") {
						escapedOrNot := escapedOrNot
						ptrOrNot := ptrOrNot
						headType := headType
						opt := opt
						typ := typ

						op := fmt.Sprintf(
							"Struct%sField%s%sHead%s%s",
							escapedOrNot,
							ptrOrNot,
							headType,
							opt,
							typ,
						)
						opTypes = append(opTypes, opType{
							Op:     op,
							Code:   "StructField",
							Indent: func() string { return fmt.Sprintf("%sIndent", op) },
							Escaped: func() string {
								switch typ {
								case "String", "StringPtr", "StringNPtr":
									return fmt.Sprintf(
										"StructEscapedField%s%sHead%sEscaped%s",
										ptrOrNot,
										headType,
										opt,
										typ,
									)
								}
								return fmt.Sprintf(
									"StructEscapedField%s%sHead%s%s",
									ptrOrNot,
									headType,
									opt,
									typ,
								)
							},
							HeadToPtrHead: func() string {
								return fmt.Sprintf(
									"Struct%sFieldPtr%sHead%s%s",
									escapedOrNot,
									headType,
									opt,
									typ,
								)
							},
							HeadToNPtrHead: func() string {
								return fmt.Sprintf(
									"Struct%sFieldNPtr%sHead%s%s",
									escapedOrNot,
									headType,
									opt,
									typ,
								)
							},
							HeadToAnonymousHead: func() string {
								return fmt.Sprintf(
									"Struct%sField%sAnonymousHead%s%s",
									escapedOrNot,
									ptrOrNot,
									opt,
									typ,
								)
							},
							HeadToOmitEmptyHead: func() string {
								return fmt.Sprintf(
									"Struct%sField%s%sHeadOmitEmpty%s",
									escapedOrNot,
									ptrOrNot,
									headType,
									typ,
								)
							},
							HeadToStringTagHead: func() string {
								return fmt.Sprintf(
									"Struct%sField%s%sHeadStringTag%s",
									escapedOrNot,
									ptrOrNot,
									headType,
									typ,
								)
							},
							PtrHeadToHead: func() string {
								return fmt.Sprintf(
									"Struct%sField%sHead%s%s",
									escapedOrNot,
									headType,
									opt,
									typ,
								)
							},
							FieldToEnd:            func() string { return op },
							FieldToOmitEmptyField: func() string { return op },
							FieldToStringTagField: func() string { return op },
						})
					}
				}
			}
		}
	}
	for _, escapedOrNot := range []string{"", "Escaped"} {
		for _, opt := range []string{"", "OmitEmpty", "StringTag"} {
			for _, typ := range append(primitiveTypesUpper, "") {
				escapedOrNot := escapedOrNot
				opt := opt
				typ := typ

				op := fmt.Sprintf(
					"Struct%sField%s%s",
					escapedOrNot,
					opt,
					typ,
				)
				opTypes = append(opTypes, opType{
					Op:     op,
					Code:   "StructField",
					Indent: func() string { return fmt.Sprintf("%sIndent", op) },
					Escaped: func() string {
						switch typ {
						case "String", "StringPtr", "StringNPtr":
							return fmt.Sprintf(
								"StructEscapedField%sEscaped%s",
								opt,
								typ,
							)
						}
						return fmt.Sprintf(
							"StructEscapedField%s%s",
							opt,
							typ,
						)
					},
					HeadToPtrHead:       func() string { return op },
					HeadToNPtrHead:      func() string { return op },
					HeadToAnonymousHead: func() string { return op },
					HeadToOmitEmptyHead: func() string { return op },
					HeadToStringTagHead: func() string { return op },
					PtrHeadToHead:       func() string { return op },
					FieldToEnd: func() string {
						switch typ {
						case "", "Array", "Map", "MapLoad", "Slice", "Struct", "Recursive":
							return op
						}
						return fmt.Sprintf(
							"Struct%sEnd%s%s",
							escapedOrNot,
							opt,
							typ,
						)
					},
					FieldToOmitEmptyField: func() string {
						return fmt.Sprintf(
							"Struct%sFieldOmitEmpty%s",
							escapedOrNot,
							typ,
						)
					},
					FieldToStringTagField: func() string {
						return fmt.Sprintf(
							"Struct%sFieldStringTag%s",
							escapedOrNot,
							typ,
						)
					},
				})
			}
		}
	}
	for _, escapedOrNot := range []string{"", "Escaped"} {
		for _, opt := range []string{"", "OmitEmpty", "StringTag"} {
			for _, typ := range append(primitiveTypesUpper, "") {
				escapedOrNot := escapedOrNot
				opt := opt
				typ := typ

				op := fmt.Sprintf(
					"Struct%sEnd%s%s",
					escapedOrNot,
					opt,
					typ,
				)
				opTypes = append(opTypes, opType{
					Op:     op,
					Code:   "StructEnd",
					Indent: func() string { return fmt.Sprintf("%sIndent", op) },
					Escaped: func() string {
						switch typ {
						case "String", "StringPtr", "StringNPtr":
							return fmt.Sprintf(
								"StructEscapedEnd%sEscaped%s",
								opt,
								typ,
							)
						}
						return fmt.Sprintf(
							"StructEscapedEnd%s%s",
							opt,
							typ,
						)
					},
					HeadToPtrHead:         func() string { return op },
					HeadToNPtrHead:        func() string { return op },
					HeadToAnonymousHead:   func() string { return op },
					HeadToOmitEmptyHead:   func() string { return op },
					HeadToStringTagHead:   func() string { return op },
					PtrHeadToHead:         func() string { return op },
					FieldToEnd:            func() string { return op },
					FieldToOmitEmptyField: func() string { return op },
					FieldToStringTagField: func() string { return op },
				})
			}
		}
	}
	indentOpTypes := []opType{}
	for _, typ := range opTypes {
		typ := typ
		indentOpTypes = append(indentOpTypes, opType{
			Op:      fmt.Sprintf("%sIndent", typ.Op),
			Code:    typ.Code,
			Indent:  func() string { return fmt.Sprintf("%sIndent", typ.Op) },
			Escaped: func() string { return fmt.Sprintf("%sIndent", typ.Escaped()) },
			HeadToPtrHead: func() string {
				return fmt.Sprintf("%sIndent", typ.HeadToPtrHead())
			},
			HeadToNPtrHead: func() string {
				return fmt.Sprintf("%sIndent", typ.HeadToNPtrHead())
			},
			HeadToAnonymousHead: func() string {
				return fmt.Sprintf("%sIndent", typ.HeadToAnonymousHead())
			},
			HeadToOmitEmptyHead: func() string {
				return fmt.Sprintf("%sIndent", typ.HeadToOmitEmptyHead())
			},
			HeadToStringTagHead: func() string {
				return fmt.Sprintf("%sIndent", typ.HeadToStringTagHead())
			},
			PtrHeadToHead: func() string {
				return fmt.Sprintf("%sIndent", typ.PtrHeadToHead())
			},
			FieldToOmitEmptyField: func() string {
				return fmt.Sprintf("%sIndent", typ.FieldToOmitEmptyField())
			},
			FieldToStringTagField: func() string {
				return fmt.Sprintf("%sIndent", typ.FieldToStringTagField())
			},
			FieldToEnd: func() string {
				return fmt.Sprintf("%sIndent", typ.FieldToEnd())
			},
		})
	}
	var b bytes.Buffer
	if err := tmpl.Execute(&b, struct {
		CodeTypes        []string
		OpTypes          []opType
		OpNotIndentTypes []opType
		OpLen            int
		OpIndentLen      int
	}{
		CodeTypes:        codeTypes,
		OpTypes:          append(opTypes, indentOpTypes...),
		OpNotIndentTypes: opTypes,
		OpLen:            len(opTypes),
		OpIndentLen:      len(indentOpTypes),
	}); err != nil {
		return err
	}
	path := filepath.Join(repoRoot(), "encode_optype.go")
	buf, err := format.Source(b.Bytes())
	if err != nil {
		return err
	}
	return ioutil.WriteFile(path, buf, 0644)
}

func repoRoot() string {
	_, file, _, _ := runtime.Caller(0)
	relativePathFromRepoRoot := filepath.Join("cmd", "generator")
	return strings.TrimSuffix(filepath.Dir(file), relativePathFromRepoRoot)
}

func main() {
	if err := _main(); err != nil {
		panic(err)
	}
}