package gateway

import (
	"encoding/json"
	"errors"
	pb "git.loafle.net/overflow/overflow_api_service/grpc"
	"github.com/golang/glog"
	"golang.org/x/net/context"
	"log"
	"reflect"

	"git.loafle.net/overflow/overflow_service/proxy/member"
	"git.loafle.net/overflow/overflow_service/proxy/noauthprobe"
	"git.loafle.net/overflow/overflow_service/proxy/probe"
	"git.loafle.net/overflow/overflow_service/proxy/sensor"
	"git.loafle.net/overflow/overflow_service/proxy/target"
	//"google.golang.org/grpc/metadata"
)

var g_services map[string]interface{}

func AddServices(name string, s interface{}) {
	if g_services == nil {
		g_services = make(map[string]interface{}, 0)
	}

	g_services[name] = s
}

type Services interface {
	GetModel() interface{}
}

func InitServices() {
	g_services = make(map[string]interface{}, 0)

	// proxy services save
	AddServices("Member", member.NewMemberService())
	AddServices("NoAuthProbe", noauthprobe.NewNoAuthProbeService())
	AddServices("Probe", probe.NewProbeService())
	AddServices("Target", target.NewTargetService())
	AddServices("Sensor", sensor.NewSensorService())
}

type ServiceImpl struct {
}

func (s *ServiceImpl) ExecServices(c context.Context, in *pb.ServiceInput) (*pb.ServiceOutput, error) {
	// Check Service Name
	serviceName, ok := g_services[in.ServiceName]
	//metadata.FromContext(c)
	log.Println("Service Name : " + in.ServiceName + " MethodName : " + in.MethodName)

	if !ok {

		return nil, errors.New("Not Exist Service Name")
	}

	pbs := &pb.ServiceOutput{}
	methodName := reflect.ValueOf(serviceName).MethodByName(in.MethodName)

	if methodName.IsValid() == false {
		return pbs, errors.New("Not Exist Method Name")
	}

	params := make([]reflect.Value, methodName.Type().NumIn())
	var NewObj reflect.Value

	for i := 0; i < methodName.Type().NumIn(); i++ {
		temp := methodName.Type().In(i)

		switch temp.Kind() {
		case reflect.Ptr:
			NewObj = reflect.New(temp.Elem())
		}
		convertParam(NewObj.Interface(), in.Param)
		params[i] = NewObj
	}

	// Todo Call Service Method
	results := methodName.Call(params)

	result := results[0].Interface().(string)

	var err error = nil
	if len(result) > 1 {
		obj := results[1].Interface()
		if obj != nil {
			log.Println("err : " + err.Error())
			err = obj.(error)
			return pbs, err
		}
	}

	pbs.ResultStr = result

	return pbs, nil
}

func convertParam(sn interface{}, param map[string]string) {

	// param convert string
	//paramStr, err := json.Marshal(param)
	//if err != nil {
	//	glog.Fatal("Json Marshal Failed : ", err.Error())
	//}

	paramStr := param["model"]
	// service converting
	log.Println("input model : ", paramStr)
	err := json.Unmarshal([]byte(paramStr), sn)
	if err != nil {
		glog.Fatal("Json Unmarshal Failed : ", err.Error())
	}

}