package gateway

import (
	"golang.org/x/net/context"
	pb "git.loafle.net/overflow/overflow_api_service/grpc"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/member"
	"github.com/golang/glog"
	"encoding/json"
	"reflect"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/noauthagent"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/target"
	//"git.loafle.net/overflow/overflow_proxy_service/proxy/agent"
	"errors"

	"git.loafle.net/overflow/overflow_proxy_service/proxy/crawler"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/crawlerInputItem"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/crawlerinputitemmapping"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/sensor"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/sensorItem"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/sensorItemCategory"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/sensorItemMapping"
)

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("Agent", agent.NewAgentService())
	AddServices("Member", member.NewMemberService())
	AddServices("NoAuthAgent", noauthagent.NewNoAuthAgentService())
	AddServices("Target", target.NewTargetService())
	AddServices("Crawler", crawler.NewCrawlerService())
	AddServices("CrawlerInputItem", crawlerInputItem.NewCrawlerInputItemService())
	AddServices("CrawlerInputItemMapping", crawlerinputitemmapping.NewCrawlerInputItemMappingService())
	AddServices("Sensor", sensor.NewSensorService())
	AddServices("SensorItem", sensorItem.NewSensorItemService())
	AddServices("SensorItemCategory", sensorItemCategory.NewSensorItemCategoryService())
	AddServices("SensorItemMapping", sensorItemMapping.NewSensorItemMappingService())

}
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]

	if !ok {

		return nil, errors.New("Not Exist Service Name")
	}
	pbs := &pb.ServiceOutput{}
	methodName := reflect.ValueOf(serviceName).MethodByName(in.MethodName)
	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
	result := methodName.Call(params)[0].String()

	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
	err := json.Unmarshal([]byte(paramStr), sn)
	if err != nil {
		glog.Fatal("Json Unmarshal Failed : ", err.Error())
	}

}