package target

import (
	"encoding/json"
	"git.loafle.net/overflow/commons_go/model/timestamp"
	"git.loafle.net/overflow/overflow_service/proxy/infra"
	"git.loafle.net/overflow/overflow_service/proxy/probe"
	"git.loafle.net/overflow/overflow_service/proxy/utils"
	"strconv"
	"git.loafle.net/overflow/overflow_service/proxy/meta"
	"git.loafle.net/overflow/discovery/discovery/types"
)

type Target struct {
	Id         json.Number         `json:"id,Number,omitempty"`
	CreateDate timestamp.Timestamp `json:"createDate,omitempty"`
	Probe      *probe.Probe        `json:"probe,omitempty"`
	Infra      *infra.Infra        `json:"infra,omitempty"`
}

type TargetInfo struct {

	Hosts  *[]*types.DiscoveryHost		`json:"hosts,omitempty"`
	Probe *probe.Probe			`json:"probe,omitempty"`
}

type TargetService struct {
}

func NewTargetService() *TargetService {
	return &TargetService{}
}

func (t *TargetService) GetModel() interface{} {
	return &Target{}
}

func (t *TargetService) ReadAllByProbe(p *probe.Probe) (string, error) {

	out, err := utils.InvokeDBByModel("target", "findAllByProbe", p, utils.MODEL_PROBE)

	if err != nil {
		return "", err
	}

	return out, err
}

func (t *TargetService) Regist(target *Target) (string, error) {
	out, err := utils.InvokeDBByModel("target", "save", target, utils.MODEL_TARGET)

	if err != nil {
		return "", err
	}

	return out, nil
}

func (t *TargetService) Read(id string) (string, error) {

	out, err := utils.InvokeDBByModel("target", "findOne", id, utils.MODEL_LONG)

	if err != nil {
		return "", err
	}

	return out, nil
}

func (t *TargetService) Remove(target *Target) (string, error) {

	out, err := utils.InvokeDBByModel("target", "delete", target, utils.MODEL_TARGET)

	if err != nil {
		return "", err
	}

	return out, nil
}

//FIXME:  Discovery Result
func (t *TargetService) RegistTarget(ti *TargetInfo) (string, error) {

	is := infra.NewInfraService()

	for _, host := range *ti.Hosts {

		im := infra.InfraMachine{}
		im.Probe = *ti.Probe

		out, err := is.RegistMachine(&im)

		if err != nil {
			return "", err
		}

		err = json.Unmarshal([]byte(out), &im)
		if err != nil {
			return "", err
		}

		io := infra.InfraOS{}
		io.InfraMachine = im
		miv := meta.MetaInfraVendor{}
		if host.Os == "Windows" {
			miv.Id = "25"
		} else if host.Os == "Linux" {
			miv.Id = "27"
		}
		io.MetaInfraVendor = miv

		ih := infra.InfraHost{}
		ih.InfraOS = io
		ih.Ip = json.Number(strconv.FormatInt(host.Ip, 10))
		ih.Mac = json.Number(strconv.FormatInt(host.Mac, 10))

		//i := infra.Infra{}


		for _, port := range host.Ports{

			ip := infra.InfraOSPort{}
			ip.InfraOS = io
			ip.Port = json.Number(strconv.FormatUint(uint64(port.Number), 10))
			ip.PortType = port.PortType
			//ip.MetaInfraVendor
			//ip.TlsType

			for _, service := range port.Services {

				isa := infra.InfraServiceApplication{}

				isa.InfraHost = ih
				isa.PortType = port.PortType
				//isa.TlsType
				isa.Port = json.Number(strconv.FormatUint(uint64(port.Number), 10))
				//isa.MetaInfraVendor
				isa.MetaInfraVendor = *meta.NewMetaInfraVendorByService(service.ServiceName)
			}

		}


	}


	return "", nil
}