package infrastructure

import (
	"encoding/json"
	"fmt"
	"slices"
	"sync"
	"time"

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

var ressourceCols = []oclib.LibDataEnum{
	oclib.LibDataEnum(oclib.PEER),
}

var SearchMu sync.RWMutex
var SearchStreamAction = map[string][]*peer.Peer{}
var SearchStream = map[string]chan WSMessage{}

func EmitNATS(user string, groups []string, message tools.PropalgationMessage) {
	b, _ := json.Marshal(message)
	if message.Action == tools.PB_SEARCH {
		SearchMu.Lock()
		SearchStream[user] = make(chan WSMessage, 128)
		SearchStreamAction[user] = []*peer.Peer{}
		fmt.Println("NEW PB")
		SearchMu.Unlock()
	}
	tools.NewNATSCaller().SetNATSPub(tools.PROPALGATION_EVENT, tools.NATSResponse{
		FromApp:  "oc-peer",
		Datatype: -1,
		User:     user,
		Groups:   groups,
		Method:   int(tools.PROPALGATION_EVENT),
		Payload:  b,
	})
}

var self *peer.Peer

func ListenNATS() {
	tools.NewNATSCaller().ListenNats(map[tools.NATSMethod]func(tools.NATSResponse){
		tools.CREATE_RESOURCE: func(resp tools.NATSResponse) {
			if resp.FromApp == config.GetAppName() || !slices.Contains(ressourceCols, oclib.LibDataEnum(resp.Datatype)) {
				return
			}
			self, _ := oclib.GetMySelf()
			if self != nil && self.IsNano {
				return
			}
			p := &peer.Peer{}
			if err := json.Unmarshal(resp.Payload, &p); err == nil {
				fmt.Println("CREATE_RESOURCE", p.GetID())

				if self.GetID() == p.GetID() {
					fmt.Println("it's ourselve !")
					return
				}

				access := oclib.NewRequestAdmin(oclib.LibDataEnum(resp.Datatype), nil)
				if data := access.LoadOne(p.GetID()); data.Data != nil {
					if p.Relation == peer.PENDING_PARTNER || p.Relation == peer.PARTNER {
						if data.ToPeer().Verify {
							fmt.Println("UPDATE 2", p.GetID())
							access.UpdateOne(map[string]interface{}{
								"verify":   false,
								"relation": peer.PARTNER,
							}, p.GetID())
						} else {
							access.UpdateOne(map[string]interface{}{
								"verify":   true,
								"relation": peer.PENDING_PARTNER,
							}, p.GetID())
						}
					} else if data.ToPeer().Relation == peer.NONE {
						access.UpdateOne(map[string]interface{}{
							"verify":   false,
							"relation": p.Relation,
						}, p.GetID())
					}
				} else if p.Relation == peer.PENDING_NANO || p.Relation == peer.NANO {
					if data.ToPeer().Verify {
						access.UpdateOne(map[string]interface{}{
							"verify":   false,
							"relation": peer.MASTER,
						}, p.GetID())
					} else {
						access.UpdateOne(map[string]interface{}{
							"verify":   true,
							"relation": peer.PENDING_MASTER,
						}, p.GetID())
					}
				} else if p.Relation != peer.SELF && p.Relation != peer.BLACKLIST {
					if p.Relation == peer.PARTNER || p.Relation == peer.PENDING_PARTNER {
						p.Verify = true
						p.Relation = peer.PENDING_PARTNER
					}
					p.IsNano = config.GetConfig().IsNano
					access.StoreOne(p.Serialize(p))
				}
			}
		},
		tools.SEARCH_EVENT: func(resp tools.NATSResponse) {
			if !slices.Contains(ressourceCols, oclib.LibDataEnum(resp.Datatype)) {
				return
			}
			p := &peer.Peer{}
			if err := json.Unmarshal(resp.Payload, p); err != nil {
				return
			}
			access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
			fmt.Println("ADD in SEARCH STREAM", p.GetID())
			if s := access.Search(&dbs.Filters{
				And: map[string][]dbs.Filter{
					"peer_id": {{Operator: dbs.EQUAL.String(), Value: p.PeerID}},
				},
			}, "", false, 0, 1); len(s.Data) > 0 {
				p.Relation = s.Data[0].(*peer.Peer).Relation
			} else {
				p.NotInCatalog = true
			}

			// Stamp volatile online state from cache.
			p.Online = IsOnline(p.PeerID)
			now := time.Now()
			if p.Online {
				p.LastHeartbeat = &now
			}

			SearchMu.RLock()
			if ch, ok := SearchStream[resp.User]; ok {
				select {
				case ch <- WSMessage{Type: "peer", Peer: p}:
				default:
				}
			}
			SearchMu.RUnlock()
		},

		// PEER_OBSERVE_RESPONSE_EVENT is emitted by oc-discovery when it
		// receives a heartbeat from an observed remote peer.
		tools.PEER_OBSERVE_RESPONSE_EVENT: func(resp tools.NATSResponse) {
			var batch struct {
				PeerIDs []string                            `json:"peer_ids"`
				Metrics map[string]*PeerConnectivityMetrics `json:"metrics"`
			}

			if err := json.Unmarshal(resp.Payload, &batch); err != nil {
				return
			}
			if len(batch.PeerIDs) == 0 {
				return
			}
			fmt.Println("METRICS", batch.Metrics)
			HandleHeartbeatBatch(batch.PeerIDs, batch.Metrics)
		},
	})
}