package node

import (
	"context"
	"encoding/json"
	"fmt"
	"oc-discovery/daemons/node/common"
	"oc-discovery/daemons/node/stream"

	oclib "cloud.o-forge.io/core/oc-lib"
	"cloud.o-forge.io/core/oc-lib/config"
	"cloud.o-forge.io/core/oc-lib/models/peer"
	"cloud.o-forge.io/core/oc-lib/tools"
	pp "github.com/libp2p/go-libp2p/core/peer"
	"github.com/libp2p/go-libp2p/core/protocol"
)

type configPayload struct {
	PeerID string `json:"source_peer_id"`
}

type executionConsidersPayload struct {
	PeerIDs []string `json:"peer_ids"`
}

func ListenNATS(n *Node) {
	tools.NewNATSCaller().ListenNats(map[tools.NATSMethod]func(tools.NATSResponse){
		/*tools.VERIFY_RESOURCE: func(resp tools.NATSResponse) {
			if resp.FromApp == config.GetAppName() {
				return
			}
			if res, err := resources.ToResource(resp.Datatype.EnumIndex(), resp.Payload); err == nil {
				access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
				p := access.LoadOne(res.GetCreatorID())
				realP := p.ToPeer()
				if realP == nil {
					return
				} else if realP.Relation == peer.SELF {
					pubKey, err := common.PubKeyFromString(realP.PublicKey) // extract pubkey from pubkey str
					if err != nil {
						return
					}
					ok, _ := pubKey.Verify(resp.Payload, res.GetSignature())
					if b, err := json.Marshal(stream.Verify{
						IsVerified: ok,
					}); err == nil {
						tools.NewNATSCaller().SetNATSPub(tools.VERIFY_RESOURCE, tools.NATSResponse{
							FromApp: "oc-discovery",
							Method:  int(tools.VERIFY_RESOURCE),
							Payload: b,
						})
					}
				} else if realP.Relation != peer.BLACKLIST {
					n.StreamService.PublishVerifyResources(&resp.Datatype, resp.User, realP.PeerID, resp.Payload)
				}
			}
		},*/
		tools.CREATE_RESOURCE: func(resp tools.NATSResponse) {
			if resp.FromApp == config.GetAppName() && resp.Datatype != tools.PEER && resp.Datatype != tools.WORKFLOW {
				return
			}
			logger := oclib.GetLogger()
			m := map[string]interface{}{}
			err := json.Unmarshal(resp.Payload, &m)
			if err != nil {
				logger.Err(err)
				return
			}
			p := &peer.Peer{}
			p = p.Deserialize(m, p).(*peer.Peer)

			ad, err := pp.AddrInfoFromString(p.StreamAddress)
			if err != nil {
				return
			}
			n.StreamService.Mu.Lock()
			defer n.StreamService.Mu.Unlock()

			if p.Relation == peer.PARTNER {
				n.StreamService.ConnectToPartner(p.StreamAddress)
			} else {
				ps := common.ProtocolStream{}
				for p, s := range n.StreamService.Streams {
					m := map[pp.ID]*common.Stream{}
					for k := range s {
						if ad.ID != k {
							m[k] = s[k]
						} else {
							s[k].Stream.Close()
						}
					}
					ps[p] = m
				}
				n.StreamService.Streams = ps
			}

		},
		tools.PROPALGATION_EVENT: func(resp tools.NATSResponse) {
			fmt.Println("PROPALGATION")
			if resp.FromApp == config.GetAppName() {
				return
			}
			var propalgation tools.PropalgationMessage
			err := json.Unmarshal(resp.Payload, &propalgation)
			var dt *tools.DataType
			if propalgation.DataType > 0 {
				dtt := tools.DataType(propalgation.DataType)
				dt = &dtt
			}
			fmt.Println("PROPALGATION ACT", propalgation.Action, propalgation.Action == tools.PB_CREATE, err)
			if err == nil {
				switch propalgation.Action {
				case tools.PB_ADMIRALTY_CONFIG, tools.PB_MINIO_CONFIG:
					var m configPayload
					var proto protocol.ID = stream.ProtocolAdmiraltyConfigResource
					if propalgation.Action == tools.PB_MINIO_CONFIG {
						proto = stream.ProtocolMinioConfigResource
					}
					if err := json.Unmarshal(resp.Payload, &m); err == nil {
						peers, _ := n.GetPeerRecord(context.Background(), m.PeerID)
						for _, p := range peers {
							n.StreamService.PublishCommon(&resp.Datatype, resp.User,
								p.PeerID, proto, resp.Payload)
						}
					}
				case tools.PB_CREATE, tools.PB_UPDATE, tools.PB_DELETE:
					fmt.Println(propalgation.Action, dt, resp.User, propalgation.Payload)
					fmt.Println(n.StreamService.ToPartnerPublishEvent(
						context.Background(),
						propalgation.Action,
						dt, resp.User,
						propalgation.Payload,
					))
				case tools.PB_CONSIDERS:
					switch resp.Datatype {
					case tools.BOOKING, tools.PURCHASE_RESOURCE, tools.WORKFLOW_EXECUTION:
						var m executionConsidersPayload
						if err := json.Unmarshal(resp.Payload, &m); err == nil {
							for _, p := range m.PeerIDs {
								peers, _ := n.GetPeerRecord(context.Background(), p)
								for _, pp := range peers {
									n.StreamService.PublishCommon(&resp.Datatype, resp.User,
										pp.PeerID, stream.ProtocolConsidersResource, resp.Payload)
								}
							}
						}
					default:
						// minio / admiralty config considers — route back to OriginID.
						var m struct {
							OriginID string `json:"origin_id"`
						}
						if err := json.Unmarshal(propalgation.Payload, &m); err == nil && m.OriginID != "" {
							peers, _ := n.GetPeerRecord(context.Background(), m.OriginID)
							for _, p := range peers {
								n.StreamService.PublishCommon(nil, resp.User,
									p.PeerID, stream.ProtocolConsidersResource, propalgation.Payload)
							}
						}
					}
				case tools.PB_PLANNER:
					m := map[string]interface{}{}
					if err := json.Unmarshal(resp.Payload, &m); err == nil {
						b := []byte{}
						if len(m) > 1 {
							b = resp.Payload
						}
						if m["peer_id"] == nil { // send to every active stream
							n.StreamService.Mu.Lock()
							if n.StreamService.Streams[stream.ProtocolSendPlanner] != nil {
								for pid := range n.StreamService.Streams[stream.ProtocolSendPlanner] {
									n.StreamService.PublishCommon(nil, resp.User, pid.String(), stream.ProtocolSendPlanner, b)
								}
							}
						} else {
							n.StreamService.PublishCommon(nil, resp.User, fmt.Sprintf("%v", m["peer_id"]), stream.ProtocolSendPlanner, b)
						}
						n.StreamService.Mu.Unlock()
					}
				case tools.PB_CLOSE_PLANNER:
					m := map[string]interface{}{}
					if err := json.Unmarshal(resp.Payload, &m); err == nil {
						n.StreamService.Mu.Lock()
						if pid, err := pp.Decode(fmt.Sprintf("%v", m["peer_id"])); err == nil {
							if n.StreamService.Streams[stream.ProtocolSendPlanner] != nil && n.StreamService.Streams[stream.ProtocolSendPlanner][pid] != nil {
								n.StreamService.Streams[stream.ProtocolSendPlanner][pid].Stream.Close()
								delete(n.StreamService.Streams[stream.ProtocolSendPlanner], pid)
							}
						}
						n.StreamService.Mu.Unlock()
					}
				case tools.PB_SEARCH:
					if propalgation.DataType == int(tools.PEER) {
						m := map[string]interface{}{}
						if err := json.Unmarshal(propalgation.Payload, &m); err == nil {
							if peers, err := n.GetPeerRecord(context.Background(), fmt.Sprintf("%v", m["search"])); err == nil {
								for _, p := range peers {
									if b, err := json.Marshal(p); err == nil {
										go tools.NewNATSCaller().SetNATSPub(tools.SEARCH_EVENT, tools.NATSResponse{
											FromApp:  "oc-discovery",
											Datatype: tools.DataType(tools.PEER),
											Method:   int(tools.SEARCH_EVENT),
											Payload:  b,
										})
									}
								}
							}
						}

					} else {
						m := map[string]interface{}{}
						if err := json.Unmarshal(propalgation.Payload, &m); err == nil {
							n.PubSubService.SearchPublishEvent(
								context.Background(),
								dt,
								fmt.Sprintf("%v", m["type"]),
								resp.User,
								fmt.Sprintf("%v", m["search"]),
							)
						}
					}
				}
			}
		},
	})
}