package main

import "git.tebibyte.media/sashakoshka/stone"

var selectedExpression Expression

type Opcode int

const (
	OpcodeUnknown Opcode = iota
	
	OpcodeAdd
	OpcodeSubtract
	OpcodeMultiply
	OpcodeDivide
	OpcodePower
	OpcodeRoot

	OpcodeModulo
	
	OpcodeOr
	OpcodeNot
	OpcodeAnd
	OpcodeXor
	OpcodeLeftShift
	OpcodeRightShift

	OpcodeMean
)

func (opcode Opcode) String () (output string) {
	switch opcode {
	case OpcodeUnknown:    output = "?"
	case OpcodeAdd:        output = "+"
	case OpcodeSubtract:   output = "-"
	case OpcodeMultiply:   output = "*"
	case OpcodeDivide:     output = "/"
	case OpcodePower:      output = "p"
	case OpcodeRoot:       output = "r"
	case OpcodeModulo:     output = "%"
	case OpcodeOr:         output = "|"
	case OpcodeNot:        output = "~"
	case OpcodeAnd:        output = "&"
	case OpcodeXor:        output = "^"
	case OpcodeLeftShift:  output = "<<"
	case OpcodeRightShift: output = ">>"
	case OpcodeMean:       output = "mean"
	}
	return
}

type Expression interface {
	Parent          () (parent *Operation)
	Next            () (next Expression)
	Previous        () (previous Expression)
	Render          (target stone.Buffer, offset int) (moved int)
	Solution        () (solution int64, err error)
	InexactSolution () (solution float64, err error)
}

type Operation struct {
	parent   *Operation
	opcode   Opcode
	operands []Expression
	floating bool

	// TODO: add bool to make this into a float
	// when it is a float:
	// - displays with parentheses instead of brackets
	// - compute solution in floating point manner
	// - return floating point solution for both Solution and
	//   InexactSolution, instead of the other way around, casting as
	//   necessary
	// - ask children for InexactSolution instead of Solution
	//
	// TODO: have some control to make the readout call InexactSolution
	// instead of Solution and display the floating point data properly
}

func (operation *Operation) Parent () (parent *Operation) {
	parent = operation.parent
	return
}

func (operation *Operation) Adopt (child Expression) {
	operation.operands = append(operation.operands, child)
	operation.adopt(child)
}

func (operation *Operation) adopt (child Expression) {
	switch child.(type) {
	case *Operation:
		child.(*Operation).parent = operation
	case *IntegerLiteral:
		child.(*IntegerLiteral).parent = operation
	}
}

func (operation *Operation) Insert (around, child Expression, after bool) {
	var operand Expression
	var index int
	var found bool
	for index, operand = range operation.operands {
		if operand == around { found = true; break }
	}

	if !found { return }
	if after { index ++ }

	operation.operands = append(operation.operands, nil)
	copy(operation.operands[index + 1:], operation.operands[index:])
	operation.operands[index] = child
	operation.adopt(child)
	
}

func (operation *Operation) Disown (child Expression) {
	var operand Expression
	var index int
	var found bool
	for index, operand = range operation.operands {
		if operand == child { found = true; break }
	}

	if !found { return }

	operation.operands = append (
		operation.operands[:index],
		operation.operands[index + 1:]...)
}

func (operation *Operation) Swap (child Expression, with Expression) {
	var operand Expression
	var index int
	var found bool
	for index, operand = range operation.operands {
		if operand == child { found = true; break }
	}

	if !found { return }

	operation.operands[index] = with
	operation.adopt(with)
}

func (operation *Operation) Next () (next Expression) {
	if operation == selectedExpression && len(operation.operands) > 0 {
		// selection descends into this operation
		next = operation.operands[0]
		return
	}

	next = operation.next(selectedExpression)
	
	return
}

func (operation *Operation) next (after Expression) (next Expression) {
	var operand Expression
	var index int
	var found bool
	for index, operand = range operation.operands {
		if operand == after { found = true; break }
	}

	if !found { return }

	index ++
	if index >= len(operation.operands) {
		// selection goes out of bounds to the right, ascending
		// out of this operation
		if operation.parent != nil {
			next = operation.parent.next(operation)
		}
	} else {
		// selection moves to the right within this operation
		next = operation.operands[index]
	}

	return
}

func (operation *Operation) Previous () (previous Expression) {
	if operation == selectedExpression {
		if operation.parent != nil {
			previous = operation.parent.Previous()
		}
		return
	}
	
	var operand Expression
	var index int
	var found bool
	for index, operand = range operation.operands {
		if operand == selectedExpression { found = true; break }
	}

	if !found {
		if operation.parent != nil {
			previous = operation.parent.Next()
		}
	} else {
		index --
		if index < 0 {
			previous = operation
		} else {
			previous = operation.operands[index]
			subOperation, isOperation := previous.(*Operation)
			if isOperation {
				previous = subOperation.Last()
				if previous == nil {
					previous = subOperation
				}
			}
		}
	}

	return
}

func (operation *Operation) Last () (last Expression) {
	if len(operation.operands) < 1 { return }
	last = operation.operands[len(operation.operands) - 1]
	return
}

func (operation *Operation) Render (target stone.Buffer, offset int) (moved int) {
	if operation.floating {
		target.SetRune(offset, 0, '(')
	} else {
		target.SetRune(offset, 0, '[')
	}
	
	if selectedExpression == operation {
		target.SetColor(offset, 0, stone.ColorBlue)
	} else {
		target.SetColor(offset, 0, stone.ColorDim)
	}
	moved ++

	opcodeSymbol := operation.opcode.String()
	for _, character := range opcodeSymbol {
		target.SetRune(offset + moved, 0, character)
		if selectedExpression == operation {
			target.SetColor(offset + moved, 0, stone.ColorBlue)
		} else {
			target.SetColor(offset + moved, 0, stone.ColorYellow)
		}
		moved ++
	}
	
	for _, operand := range operation.operands {
		target.SetRune(offset + moved, 0, ' ')
		moved ++
		moved += operand.Render(target, offset + moved)
	}
	
	if operation.floating {
		target.SetRune(offset + moved, 0, ')')
	} else {
		target.SetRune(offset + moved, 0, ']')
	}
	
	if selectedExpression == operation {
		target.SetColor(offset + moved, 0, stone.ColorBlue)
	} else {
		target.SetColor(offset + moved, 0, stone.ColorDim)
	}
	moved ++
	return
}

func (operation *Operation) Solution () (solution int64, err error) {
	if operation.floating {
		var floatSolution float64
		floatSolution, err = operation.inexactSolution()
		solution = int64(floatSolution)
	} else {
		solution, err = operation.solution()
	}
	return
}

func (operation *Operation) InexactSolution () (solution float64, err error) {
	if operation.floating {
		solution, err = operation.inexactSolution()
	} else {
		var intSolution int64
		intSolution, err = operation.solution()
		solution = float64(intSolution)
	}
	return
}

type IntegerLiteral struct {
	parent *Operation
	displayRadix int
	value int64
}

func (literal *IntegerLiteral) Parent () (parent *Operation) {
	parent = literal.parent
	return
}

func (literal *IntegerLiteral) Next () (next Expression) {
	if literal.parent != nil {
		next = literal.parent.Next()
	}
	return
}

func (literal *IntegerLiteral) Previous () (previous Expression) {
	if literal.parent != nil {
		previous = literal.parent.Previous()
	}
	return
}

func (literal *IntegerLiteral) Render (target stone.Buffer, offset int) (moved int) {
	var output []rune
	value := literal.value

	negative := false
	if value < 0 {
		negative = true
		value *= -1
	}
	
	for value > 0 {
		digit := rune(value % int64(literal.displayRadix))
		value /= int64(literal.displayRadix)

		if digit < 10 {
			digit += '0'
		} else {
			digit += 'A' - 10
		}

		output = append([]rune { digit }, output...)
	}

	if len(output) == 0 {
		output = []rune { '0' }
	}

	switch literal.displayRadix {
	case 2:
		output = append([]rune("0b"), output...)
	case 8:
		output = append([]rune("0"), output...)
	case 10:
	case 16:
		output = append([]rune("0x"), output...)
	default:
		output = append([]rune("0?"), output...)
	}

	if negative {
		output = append([]rune { '-' }, output...)
	}

	for _, character := range output {
		target.SetRune(offset + moved, 0, character)
		if selectedExpression == literal {
			target.SetColor(offset + moved, 0, stone.ColorBlue)
		} else {
			target.SetColor(offset + moved, 0, stone.ColorPurple)
		}
		moved ++
	}
	
	return
}

func (literal *IntegerLiteral) Solution () (solution int64, err error) {
	solution = literal.value
	return
}

func (literal *IntegerLiteral) InexactSolution () (solution float64, err error) {
	solution = float64(literal.value)
	return
}