package grow

import "log"

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

func (def *Definition) Grow() (*vm.Program, error) {
	high_score := 0

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

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

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

		if score > high_score {
			high_score = score

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

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

			if score == len(def.Samples) {
				return prog, nil
			}
		}
	}
}

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
}