package main

import "C"
import (
	"pge"
	"unsafe"
	"fmt"
	rt "runtime"
	rand "math/rand"
	"strings"
	probs "github.com/verdverm/go-pge/problems"
)

func main() {

}

var cps *pge.PgeSearch
var tp *probs.TreeParams
var epcomm *probs.ExprProblemComm
var trainDatas []*probs.PointSet
var testDatas []*probs.PointSet
var testDatasN int
var trainDatasN int
var ep *probs.ExprProblem
var per_eqns []*probs.ExprReportArray

var trainData *probs.PointSet
var testData *probs.PointSet

var probIndepNames []string
var probDepndNames []string

var stepResult probs.ExprReportArray
var lastStepRes *probs.ExprReport
var resultNr int

var nCurrentCoeff int 
var nMaxCoeff int

var nLastResults int

//export InitSearch
func InitSearch(maxGen int, pgeRptEpoch int, pgeRptCount int, pgeArchiveCap int, peelCnt int, evalrCount int, zeroEpsilon float64, initMethod *C.char, growMethod *C.char, sortType int) {
	cps = new(pge.PgeSearch)
	
	goInitMethod := C.GoString(initMethod);
	goGrowMethod := C.GoString(growMethod);
	
	testDatasN = 0 
	trainDatasN = 0
	nLastResults = 0
	cps.CreateDS(maxGen, pgeRptEpoch, pgeRptCount, pgeArchiveCap, peelCnt, evalrCount, zeroEpsilon, goInitMethod, goGrowMethod, sortType)
	
	cps.SetPeelCount(peelCnt)
	cps.SetGrowMethod(goGrowMethod)
	cps.SetInitMethod(goInitMethod)
	cps.SetEvalrCount(evalrCount)
}

//export InitTreeParams
func InitTreeParams(Roots *C.char, Nodes *C.char, NonTrig *C.char, Leafs *C.char, UsableVars unsafe.Pointer, nUseableVars int, MaxSize int, MinSize int, MaxDepth int, MinDepth int) {
	tp = new(probs.TreeParams)
	goRoots := C.GoString(Roots)
	goNodes := C.GoString(Nodes)
	goNonTrig := C.GoString(NonTrig)
	goLeafs := C.GoString(Leafs)
	goUsableVars := CIntArrayToSlice(UsableVars, nUseableVars)
	tp.CreateTreeParams(goRoots, goNodes, goNonTrig, goLeafs, goUsableVars, MaxSize, MinSize, MaxDepth, MinDepth)
}

//export AddTrainData
func AddTrainData(indepNames *C.char, depndNames *C.char, matrix unsafe.Pointer, nEntries int) {
	trainDatas = make([]*probs.PointSet, 1)
	trainData = new(probs.PointSet)
	
	goIndepNames := strings.Split(C.GoString(indepNames), " ")
	goDepndNames := strings.Split(C.GoString(depndNames), " ")
	
	probIndepNames = goIndepNames
	probDepndNames = goDepndNames
	
	trainData.InitTrainData(goIndepNames, goDepndNames, matrix, nEntries)
	
	trainDatas[trainDatasN] = trainData
	trainDatasN++
}

//export AddTestData
func AddTestData(indepNames *C.char, depndNames *C.char, matrix unsafe.Pointer, nEntries int) {
	testDatas = make([]*probs.PointSet, 1)
	testData = new(probs.PointSet)
	
	goIndepNames := strings.Split(C.GoString(indepNames), " ")
	goDepndNames := strings.Split(C.GoString(depndNames), " ")
	
	testData.InitTrainData(goIndepNames, goDepndNames, matrix, nEntries)
	testDatas[testDatasN] = testData
	testDatasN++
}

//export InitProblem
func InitProblem(Name *C.char, MaxIter int, HitRatio float64, SearchVar int, ProblemTypeString *C.char, numProcs int) {	
	ep = new(probs.ExprProblem)	
	
	//SysNames   []string
	//VarNames []string
	
	ep.IndepNames = probIndepNames
	ep.DepndNames = probDepndNames
	
	goName := C.GoString(Name)
	goProblemTypeString := C.GoString(ProblemTypeString)
	fmt.Printf("1\n")
	
	ep.CreatePS(goName, MaxIter, HitRatio, SearchVar, goProblemTypeString)
	ep.TreeCfg = tp;
	ep.UsableVars = tp.UsableVars
	fmt.Printf("2\n")
	
	cps.SetMaxIter(MaxIter)
	per_eqns = make([]*probs.ExprReportArray, 1)
	fmt.Printf("3\n")
	
	ep.Train = trainDatas
	ep.Test = testDatas
	fmt.Printf("4\n")
	
	initDone := make(chan int)
	rt.GOMAXPROCS(numProcs)
	rand.Seed(rand.Int63())
	fmt.Printf("5\n")
	
	epcomm = new(probs.ExprProblemComm)
	
	epcomm.Cmds = make(chan int)
    epcomm.Rpts = make(chan *probs.ExprReportArray, 64)
	epcomm.Gen = make(chan [2]int, 64)
	
	fmt.Printf("6\n")
	
	cps.SetProb(ep)
	cps.Init(initDone, ep, "dummy", epcomm)
	fmt.Printf("7\n")
}

//export GetMaxIterW
func GetMaxIterW() int {
	return cps.GetMaxIter()
}

//export SetMaxIterW
func SetMaxIterW(iter int) {
	cps.SetMaxIter(iter)
}

//export SetPeelCountW
func SetPeelCountW(cnt int) {
	cps.SetPeelCount(cnt)
}

//export SetInitMethodW
func SetInitMethodW(init string) {
	cps.SetInitMethod(init)
}

//export SetGrowMethodW
func SetGrowMethodW(grow string) {
	cps.SetGrowMethod(grow)
}

//export SetEvalrCountW
func SetEvalrCountW(cnt int) {
	cps.SetEvalrCount(cnt)
}

//export EvaluateW
func EvaluateW() {
	cps.Evaluate()
}

//export RunW
func RunW() {
	cps.Run()
}

//export LoopW
func LoopW() {
	cps.Loop()
}

//export GetStepResult
func GetStepResult(nobestpush *int, bestnewminerr *int, bestlen1 *int, bestlen2 *int, testscore *int, ncoeff *int) *C.char { // coeff unsafe.Pointer
	*nobestpush = 0
	*bestnewminerr = 0
	*bestlen1 = 0
	*bestlen2 = 0
	*testscore = 0
	
	if resultNr < len(stepResult) && stepResult != nil {
		elem := stepResult[resultNr]
		resultNr++
		lastStepRes = elem
		*bestlen1 = len(stepResult)
		if(elem != nil) {
			//if elem.Nobestpush {
			//	*nobestpush = 1;
			//} else {
			//	if elem.BestNewMinErr {
					*bestnewminerr = int(elem.TestError())
			//	}
				*testscore = elem.TestScore()
				*ncoeff = len(elem.Coeff())
				nCurrentCoeff = 0
				nMaxCoeff = len(elem.Coeff())
				//*bestlen1 = 0 //elem.Bestlen1
				*bestlen2 = 0 //elem.Bestlen2
				return C.CString(elem.Expr().String())
			//}
		}
	}
	return C.CString("")
}

//export GetCoeffResult
func GetCoeffResult() float64 {
	var res float64 = 0
	if nCurrentCoeff < nMaxCoeff {
		//item := (*float64) (unsafe.Pointer( uintptr(unsafe.Pointer(coeff)) + unsafe.Sizeof(float64(0)) * uintptr(i) ))
		//*item = elem.Coeff[i]
		
		coeffs := lastStepRes.Coeff()
		res = coeffs[nCurrentCoeff]
	}
	nCurrentCoeff++
	return res
}

//export StepW
func StepW() int {
	resultNr = 0
	stepResult = nil
	nRes := cps.Step()
	
	resu, ok := <-epcomm.Rpts
	
	//_ = ok
	
	resultNr = nLastResults
	
	nNew := 0
	if ok && resu != nil {
		stepResult = *resu
		nNew = nRes - nLastResults
		nLastResults = nRes
	}
		
	return nNew
}

//export CheckStop
func CheckStop() bool {
	if cps.GetIter() > GetMaxIterW() {
		return true
	}
	return false	
}

func CIntArrayToSlice(matrix unsafe.Pointer, nEntries int) []int {
	res := make([]int, nEntries)
	for i := 0; i < nEntries; i++ {
		item := (*int) (unsafe.Pointer( uintptr(unsafe.Pointer(matrix)) + unsafe.Sizeof(int(0)) * uintptr(i) ))
		res[i] = *item
		
		fmt.Printf("USEVAR: %v\n", *item)		
	}
	return res
}


//export TestGet
func TestGet(nix int, nix2 *C.char, nnix2 C.int) {
	fmt.Printf("TEST INT VALUE: %v \n", nix);
	fmt.Printf("TEST STRING VALUE: %v \n", nix2);
	var nixgo string
	nixgo = C.GoString(nix2);//, nnix2);	
	fmt.Printf("TEST STRING AS GOSTR VALUE: %v \n", nixgo);
}

//export CleanW
func CleanW() {
	cps.Clean()
}