package main

import "log"

import "github.com/firestuff/subcoding/asm"
import "github.com/firestuff/subcoding/gen"
import "github.com/firestuff/subcoding/vm"

func (def *Definition) Grow() {
	high_score := 0

	log.Print("Starting grow run...")

	// TODO: Score should be number of output criteria, not number of Samples
	progs := 0
	for ; high_score < len(def.Samples); progs++ {
		prog := gen.RandProgram(def.GlobalMemorySize, def.FunctionMemorySize, def.InstructionLimit)

		score, err := def.Score(prog)
		if err != nil {
			log.Fatal(err)
		}

		if score > high_score {
			high_score = score

			src, err := asm.Disassemble(prog)
			if err != nil {
				log.Fatal(err)
			}

			log.Printf("New high score %d / %d:\n%s", high_score, len(def.Samples), src)
		}
	}

	log.Printf("%d programs tested", progs)
}

func (def *Definition) Score(prog *vm.Program) (int, error) {
	score := 0

	for _, sample := range def.Samples {
		state, err := vm.NewState(prog)
		if err != nil {
			return 0, err
		}

		sample.SetInputs(state)

		state.Execute() // ignore error

		if sample.OutputsMatch(state) {
			score += 1
		}
	}

	return score, nil
}