package main

import (
	"bytes"
	"encoding/json"
	"log"
	"net/http"

	"github.com/r3labs/sse"
)

type RealtimeListener struct {
	Url         string
	Collections []string
	Create      chan PBEvent
	Update      chan PBEvent
	Delete      chan PBEvent
	client      *sse.Client
}

type Subscription struct {
	ClientId      string   `json:"clientId"`
	Subscriptions []string `json:"subscriptions"`
}

func (listener RealtimeListener) handlePbEvent(msg *sse.Event) {
	var pbEvent = new(PBEvent)
	err := json.Unmarshal(msg.Data, &pbEvent)
	if err != nil {
		log.Printf("Error unmarshalling event: %v\n", err)
		return
	}

	if pbEvent.ClientId != "" {
		listener.doSubscribe(pbEvent.ClientId)
	}

	if pbEvent.Action != "" {
		go listener.shipEvent(*pbEvent)
	}
}

func (listener RealtimeListener) shipEvent(event PBEvent) {
	switch event.Action {
	case "create":
		listener.Create <- event
	case "update":
		listener.Update <- event
	case "delete":
		listener.Delete <- event
	default:
		log.Printf("Unknown action: %v\n", event.Action)
	}
}

func (listener RealtimeListener) doSubscribe(clientId string) {
	subscription := Subscription{
		ClientId:      clientId,
		Subscriptions: listener.Collections,
	}

	body, err := json.Marshal(subscription)
	if err != nil {
		log.Printf("Error marshalling subscription body: %v\n", err)
		return
	}

	resp, err := http.Post(POCKETBASE_REALTIME, "application/json", bytes.NewBuffer(body))
	if err != nil {
		log.Printf("Error posting subscription: %v\n", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusNoContent {
		log.Printf("Subscription request failed with status: %v\n", resp.Status)
	}
}

func (listener *RealtimeListener) initialize() {
	listener.Update = make(chan PBEvent, 32)
	listener.Create = make(chan PBEvent, 32)
	listener.Delete = make(chan PBEvent, 32)
	log.Print("initialized")
	listener.client = sse.NewClient(listener.Url)
	go listener.client.Subscribe("", listener.handlePbEvent)
}