package parser

import "fmt"
import "sort"
import "git.tebibyte.media/arf/arf/lexer"

func doIndent (indent int, input ...string) (output string) {
	for index := 0; index < indent; index ++ {
		output += "\t"
	}
	for _, inputSection := range input {
		output += inputSection
	}
	return
}

func sortMapKeysAlphabetically[KEY_TYPE any] (
	unsortedMap map[string] KEY_TYPE,
) (
	sortedKeys []string,
) {
	sortedKeys = make([]string, len(unsortedMap))
	index := 0
	for key, _ := range unsortedMap {
		sortedKeys[index] = key
		index ++
	}
	sort.Strings(sortedKeys)

	return
}

func (tree SyntaxTree) ToString (indent int) (output string) {
	output += doIndent(indent, ":arf\n")

	if tree.author != "" {
		output += doIndent(indent, "author \"", tree.author, "\"\n")
	}

	if tree.license != "" {
		output += doIndent(indent, "license \"", tree.license, "\"\n")
	}

	for _, require := range tree.requires {
		output += doIndent(indent, "require \"", require, "\"\n")
	}
	
	output += doIndent(indent, "---\n")

	sectionKeys := sortMapKeysAlphabetically(tree.sections)
	for _, name := range sectionKeys {
		output += tree.sections[name].ToString(indent)
	}

	return
}

func (identifier Identifier) ToString () (output string) {
	for index, trailItem := range identifier.trail {
		if index > 0 {
			output += "."
		}

		output += trailItem
	}
	return
}

func (values ObjectDefaultValues) ToString (indent int) (output string) {
	output += doIndent(indent, "(\n")
	for name, value := range values {
		output += doIndent (
			indent,
			name + ":" + value.ToString(indent, true))
	}
	output += doIndent(indent, ")\n")
	return
}

func (values ArrayDefaultValues) ToString (indent int) (output string) {
	output += doIndent(indent, "<\n")
	for _, value := range values {
		output += doIndent(indent, value.ToString(indent, true))
	}
	output += doIndent(indent, ">\n")
	return
}

func (what Type) ToString (indent int) (output string) {
	if what.kind == TypeKindBasic {
		output += what.name.ToString()
	} else {
		output += "{"
		output += what.points.ToString(indent)

		if what.kind == TypeKindVariableArray {
			output += " .."
		}
		
		output += "}"
	}

	if what.length > 1 {
		output += fmt.Sprint(":", what.length)
	}
	
	if what.mutable {
		output += ":mut"
	}

	if what.members != nil {
		output += ":\n" + doIndent(indent, "(\n")
		for _, member := range what.members {
			output += doIndent (
				indent, member.ToString(indent + 1), "\n")
		}
		output += doIndent(indent, ")")
	}

	defaultValueKind := what.defaultValue.kind
	if defaultValueKind != ArgumentKindNil {
		isComplexDefaultValue :=
			defaultValueKind == ArgumentKindObjectDefaultValues ||
			defaultValueKind == ArgumentKindArrayDefaultValues
		
		if isComplexDefaultValue {
			output += ":\n"
			output += what.defaultValue.ToString(indent, true)
		} else {
			output += ":<"
			output += what.defaultValue.ToString(indent, false)
			output += ">\n"
		}
	}
	return
}

func (declaration Declaration) ToString (indent int) (output string) {
	output += declaration.name + ":"
	output += declaration.what.ToString(indent)
	return
}

func (argument Argument) ToString (indent int, breakLine bool) (output string) {
	if !breakLine { indent = 0 }
	if argument.kind == ArgumentKindNil {
		output += "NIL-ARGUMENT"
		if breakLine { output += "\n" }
		return
	}

	switch argument.kind {
	case ArgumentKindPhrase:
		output += argument.value.(Phrase).ToString (	
				indent,
				breakLine)
	
	case ArgumentKindObjectDefaultValues:
		output += argument.value.(ObjectDefaultValues).
				ToString(indent)
		if breakLine { output += "\n" }
	
	case ArgumentKindArrayDefaultValues:
		output += argument.value.(ArrayDefaultValues).
				ToString(indent)
		if breakLine { output += "\n" }
	
	case ArgumentKindIdentifier:
		output += doIndent (
			indent,
			argument.value.(Identifier).ToString())
		if breakLine { output += "\n" }
	
	case ArgumentKindDeclaration:
		output += doIndent (
			indent,
			argument.value.(Declaration).ToString(indent))
		if breakLine { output += "\n" }
	
	case ArgumentKindInt, ArgumentKindUInt, ArgumentKindFloat:
		output += doIndent(indent, fmt.Sprint(argument.value))
		if breakLine { output += "\n" }
	
	case ArgumentKindString:
		output += doIndent (
			indent,
			"\"" + argument.value.(string) + "\"")
		if breakLine { output += "\n" }
		
	case ArgumentKindRune:
		output += doIndent (
			indent,
			"'" + string(argument.value.(rune)) + "'")
		if breakLine { output += "\n" }
		
	case ArgumentKindOperator:
		var stringValue string
		switch argument.value.(lexer.TokenKind) {
	        case lexer.TokenKindColon:
	        	stringValue = ":"
	        case lexer.TokenKindPlus:
	        	stringValue = "+"
	        case lexer.TokenKindMinus:
	        	stringValue = "-"
	        case lexer.TokenKindIncrement:
	        	stringValue = "++"
	        case lexer.TokenKindDecrement:
	        	stringValue = "--"
	        case lexer.TokenKindAsterisk:
	        	stringValue = "*"
	        case lexer.TokenKindSlash:
	        	stringValue = "/"
	        case lexer.TokenKindExclamation:
	        	stringValue = "!"
	        case lexer.TokenKindPercent:
	        	stringValue = "%"
	        case lexer.TokenKindPercentAssignment:
	        	stringValue = "%="
	        case lexer.TokenKindTilde:
	        	stringValue = "~"
	        case lexer.TokenKindTildeAssignment:
	        	stringValue = "~="
	        case lexer.TokenKindAssignment:
	        	stringValue = "="
	        case lexer.TokenKindEqualTo:
	        	stringValue = "=="
	        case lexer.TokenKindNotEqualTo:
	        	stringValue = "!="
	        case lexer.TokenKindLessThanEqualTo:
	        	stringValue = "<="
	        case lexer.TokenKindLessThan:
	        	stringValue = "<"
	        case lexer.TokenKindLShift:
	        	stringValue = "<<"
	        case lexer.TokenKindLShiftAssignment:
	        	stringValue = "<<="
	        case lexer.TokenKindGreaterThan:
	        	stringValue = ">"
	        case lexer.TokenKindGreaterThanEqualTo:
	        	stringValue = ">="
	        case lexer.TokenKindRShift:
	        	stringValue = ">>"
	        case lexer.TokenKindRShiftAssignment:
	        	stringValue = ">>="
	        case lexer.TokenKindBinaryOr:
	        	stringValue = "|"
	        case lexer.TokenKindBinaryOrAssignment:
	        	stringValue = "|="
	        case lexer.TokenKindLogicalOr:
	        	stringValue = "||"
	        case lexer.TokenKindBinaryAnd:
	        	stringValue = "&"
	        case lexer.TokenKindBinaryAndAssignment:
	        	stringValue = "&="
	        case lexer.TokenKindLogicalAnd:
	        	stringValue = "&&"
	        case lexer.TokenKindBinaryXor:
	        	stringValue = "^"
	        case lexer.TokenKindBinaryXorAssignment:
	        	stringValue = "^="
		}
		output += doIndent(indent, stringValue)
		if breakLine { output += "\n" }
	}

	return
}

func (section DataSection) ToString (indent int) (output string) {
	output += doIndent (
		indent,
		"data ",
		section.permission.ToString(), " ",
		section.name, ":",
		section.what.ToString(indent), "\n")
	return
}

func (member TypeMember) ToString (indent int) (output string) {
	output += doIndent(indent)
	
	output += member.permission.ToString() + " "
	output += member.name + ":"
	output += member.what.ToString(indent)

	if member.bitWidth > 0 {
		output += fmt.Sprint(" & ", member.bitWidth)
	}

	output += "\n"

	return
}

func (section TypeSection) ToString (indent int) (output string) {
	output += doIndent (
		indent,
		"type ",
		section.permission.ToString(), " ",
		section.name, ":",
		section.what.ToString(indent), "\n")
	return
}


func (section EnumSection) ToString (indent int) (output string) {
	output += doIndent (
		indent,
		"enum ",
		section.permission.ToString(), " ",
		section.name, ":",
		section.what.ToString(indent), "\n")

	for _, member := range section.members {
		output += doIndent(indent + 1, member.name)
	
		isComplexInitialization :=
			member.value.kind == ArgumentKindObjectDefaultValues ||
			member.value.kind == ArgumentKindArrayDefaultValues
		
		if member.value.value == nil {
			output += "\n"
		} else if isComplexInitialization {
			output += "\n"
			output += member.value.ToString(indent + 2, true)
		} else {
			output += " " + member.value.ToString(0, false)
			output += "\n"
		}
	}
	return
}

func (section FaceSection) ToString (indent int) (output string) {
	output += doIndent (
		indent,
		"face ",
		section.permission.ToString(), " ",
		section.name, ":",
		section.inherits.ToString(), "\n")

	for _, name := range sortMapKeysAlphabetically(section.behaviors) {
		behavior := section.behaviors[name]
		output += behavior.ToString(indent + 1)
	}
	return
}

func (behavior FaceBehavior) ToString (indent int) (output string) {
	output += doIndent(indent, behavior.name, "\n")
	
	for _, inputItem := range behavior.inputs {
		output += doIndent(indent + 1, "> ", inputItem.ToString(indent), "\n")
	}
	
	for _, outputItem := range behavior.outputs {
		output += doIndent(indent + 1, "< ", outputItem.ToString(indent), "\n")
	}

	return
}

func (phrase Phrase) ToString (indent int, ownLine bool) (output string) {
	if ownLine {
		output += doIndent(indent)
	}

	var initializationValues Argument
	var declaration Argument
	
	output += "[" + phrase.command.ToString(0, false)
	for _, argument := range phrase.arguments {
		isInitializationValue :=
			argument.kind == ArgumentKindObjectDefaultValues ||
			argument.kind == ArgumentKindArrayDefaultValues
		if isInitializationValue {
			initializationValues = argument
		} else if argument.kind == ArgumentKindDeclaration {
			declaration = argument
		} else {
			output += " " + argument.ToString(0, false)
		}
	}
	output += "]"

	if len(phrase.returnees) > 0 {
		output += " ->"
		for _, returnItem := range phrase.returnees {
			output += " " + returnItem.ToString(0, false)
		}
	}

	if ownLine {
		output += "\n"

		// TODO: make = phrases special, have them carry a declaration
		// and argument and nothing else. somehow.
		for _, member := range declaration.value.(Declaration).what.members {
			output += member.ToString(indent + 1)
		}
		
		if initializationValues.kind != ArgumentKindNil {
			output += initializationValues.ToString(indent + 1, true)
		}
		output += phrase.block.ToString(indent + 1)
	}
	return
}

func (block Block) ToString (indent int) (output string) {
	for _, phrase := range block {
		output += phrase.ToString(indent, true)
	}

	return
}

func (funcOutput FuncOutput) ToString (indent int) (output string) {
	output += doIndent (
		indent + 1,
		"< ", funcOutput.Declaration.ToString(indent), "\n")
	return
}

func (section FuncSection) ToString (indent int) (output string) {
	output += doIndent (
		indent,
		"func ",
		section.permission.ToString(), " ",
		section.name, "\n")
	
	if section.receiver != nil {
		output += doIndent (
			indent + 1,
			"@ ", section.receiver.ToString(indent), "\n")
	}
	
	for _, inputItem := range section.inputs {
		output += doIndent(indent + 1, "> ", inputItem.ToString(indent), "\n")
	}
	
	for _, outputItem := range section.outputs {
		output += outputItem.ToString(indent + 1)
	}

	output += doIndent(indent + 1, "---\n")

	if section.external {
		output += doIndent(indent + 1, "external\n")
	}
	
	output += section.root.ToString(indent + 1)
	return
}