package stream

import (
	"context"
	"crypto/subtle"
	"encoding/json"
	"errors"
	"oc-discovery/daemons/node/common"
	"strings"

	oclib "cloud.o-forge.io/core/oc-lib"
	"cloud.o-forge.io/core/oc-lib/models/peer"
	"cloud.o-forge.io/core/oc-lib/models/resources"
	"cloud.o-forge.io/core/oc-lib/tools"
)

type Verify struct {
	IsVerified bool `json:"is_verified"`
}

func (ps *StreamService) getTopicName(topicName string) string {
	ns := strings.Split(topicName, ".")
	if len(ns) > 0 {
		return ns[0]
	}
	return tools.NONE.String()
}

func (ps *StreamService) handleEvent(topicName string, evt *common.Event) error {
	action := ps.getTopicName(topicName)
	ps.handleEventFromPartner(evt, action)
	if action == "verify_resource" {
		if evt.DataType == -1 {
			tools.NewNATSCaller().SetNATSPub(tools.VERIFY_RESOURCE, tools.NATSResponse{
				FromApp: "oc-discovery",
				Method:  int(tools.VERIFY_RESOURCE),
				Payload: evt.Payload,
			})
		} else if err := ps.verifyResponse(evt); err != nil {
			return err
		}
	}
	if action == tools.PB_SEARCH_RESPONSE.String() {
		if err := ps.retrieveResponse(evt); err != nil {
			return err
		}
	}
	return errors.New("no action authorized available : " + action)
}

func (abs *StreamService) verifyResponse(event *common.Event) error { //
	res, err := resources.ToResource(int(event.DataType), event.Payload)
	if err != nil || res == nil {
		return nil
	}
	verify := Verify{
		IsVerified: false,
	}
	access := oclib.NewRequestAdmin(oclib.LibDataEnum(event.DataType), nil)
	data := access.LoadOne(res.GetID())
	if data.Err == "" && data.Data != nil {
		if b, err := json.Marshal(data.Data); err == nil {
			if res2, err := resources.ToResource(int(event.DataType), b); err == nil {
				verify.IsVerified = subtle.ConstantTimeCompare(res.GetSignature(), res2.GetSignature()) == 1
			}
		}
	}
	if b, err := json.Marshal(verify); err == nil {
		abs.PublishVerifyResources(nil, "", event.From, b)
	}
	return nil
}

func (abs *StreamService) retrieveResponse(event *common.Event) error { //
	res, err := resources.ToResource(int(event.DataType), event.Payload)
	if err != nil || res == nil {
		return nil
	}
	b, err := json.Marshal(res.Serialize(res))
	go tools.NewNATSCaller().SetNATSPub(tools.CATALOG_SEARCH_EVENT, tools.NATSResponse{
		FromApp:  "oc-discovery",
		Datatype: tools.DataType(event.DataType),
		Method:   int(tools.CATALOG_SEARCH_EVENT),
		Payload:  b,
	})
	return nil
}

func (ps *StreamService) handleEventFromPartner(evt *common.Event, action string) error {
	resource, err := resources.ToResource(int(evt.DataType), evt.Payload)
	if err != nil {
		return err
	}
	b, err := json.Marshal(resource)
	if err != nil {
		return err
	}
	switch action {
	case tools.PB_SEARCH.String():
		access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
		peers := access.Search(nil, evt.From, false)
		if len(peers.Data) > 0 {
			p := peers.Data[0].(*peer.Peer)
			// TODO : something if peer is missing in our side !
			ps.SendResponse(p, evt)
		} else if p, err := ps.Node.GetPeerRecord(context.Background(), evt.From); err == nil && len(p) > 0 { // peer from is peerID
			ps.SendResponse(p[0], evt)
		}
	case tools.PB_CREATE.String():
	case tools.PB_UPDATE.String():
		go tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
			FromApp:  "oc-discovery",
			Datatype: tools.DataType(evt.DataType),
			Method:   int(tools.CREATE_RESOURCE),
			Payload:  b,
		})
	case tools.PB_DELETE.String():
		go tools.NewNATSCaller().SetNATSPub(tools.REMOVE_RESOURCE, tools.NATSResponse{
			FromApp:  "oc-discovery",
			Datatype: tools.DataType(evt.DataType),
			Method:   int(tools.REMOVE_RESOURCE),
			Payload:  b,
		})
	default:
		return errors.New("no action authorized available : " + action)
	}
	return nil
}

func (abs *StreamService) SendResponse(p *peer.Peer, event *common.Event) error {
	dts := []oclib.LibDataEnum{oclib.LibDataEnum(event.DataType)}
	if event.DataType == -1 { // expect all resources
		dts = []oclib.LibDataEnum{oclib.LibDataEnum(oclib.COMPUTE_RESOURCE), oclib.LibDataEnum(oclib.STORAGE_RESOURCE),
			oclib.LibDataEnum(oclib.PROCESSING_RESOURCE), oclib.LibDataEnum(oclib.DATA_RESOURCE), oclib.LibDataEnum(oclib.WORKFLOW_RESOURCE)}
	}
	var m map[string]string
	err := json.Unmarshal(event.Payload, &m)
	if err != nil {
		return err
	}
	for _, dt := range dts {
		access := oclib.NewRequestAdmin(oclib.LibDataEnum(event.DataType), nil)
		peerID := p.GetID()
		searched := access.Search(abs.FilterPeer(peerID, m["search"]), "", false)
		for _, ss := range searched.Data {
			if j, err := json.Marshal(ss); err == nil {
				if event.DataType != -1 {
					ndt := tools.DataType(dt.EnumIndex())
					abs.PublishResources(&ndt, event.User, peerID, j)
				} else {
					abs.PublishResources(nil, event.User, peerID, j)
				}
			}
		}
	}
	return nil
}