package common

import (
	"encoding/json"
	"errors"
	"fmt"
	"slices"
	"strings"
)

const (
	ObsMessageType_PackageBuildFail      = "package.build_fail"
	ObsMessageType_PackageBuildSuccess   = "package.build_success"
	ObsMessageType_PackageBuildUnchanged = "package.build_unchanged"

	ObsMessageType_RepoBuildFinished = "repo.build_finished"
	ObsMessageType_RepoBuildStarted  = "repo.build_started"
)

type BuildResultMsg struct {
	Status  string
	Project string `json:"project"`
	Package string `json:"package"`
	Repo    string `json:"repository"`
	Arch    string `json:"arch"`

	StartTime int32  `json:"starttime"`
	EndTime   int32  `json:"endtime"`
	WorkerID  string `json:"workerid"`
	Version   string `json:"versrel"`
	Build     string `json:"buildtype"`
}

type RepoBuildMsg struct {
	Status  string
	Project string `json:"project"`
	Repo    string `json:"repo"`
	Arch    string `json:"arch"`
	BuildId string `json:"buildid"`
}

var ObsRabbitMessageError_UnknownMessageType error = errors.New("Unknown message type")
var ObsRabbitMessageError_ParseError error = errors.New("JSON parsing error")

func ParseObsRabbitMessaege(ObsMessageType string, data []byte) (interface{}, error) {
	unmarshall := func(data []byte, v any) (interface{}, error) {
		if err := json.Unmarshal(data, v); err != nil {
			return nil, fmt.Errorf("%w: %s", ObsRabbitMessageError_ParseError, err)
		}
		return v, nil
	}

	switch ObsMessageType {
	case ObsMessageType_PackageBuildSuccess, ObsMessageType_PackageBuildUnchanged:
		ret := &BuildResultMsg{Status: "succeeded"}
		return unmarshall(data, ret)
	case ObsMessageType_PackageBuildFail:
		ret := &BuildResultMsg{Status: "failed"}
		return unmarshall(data, ret)
	case ObsMessageType_RepoBuildFinished:
		ret := &RepoBuildMsg{Status: "finished"}
		return unmarshall(data, ret)
	case ObsMessageType_RepoBuildStarted:
		ret := &RepoBuildMsg{Status: "building"}
		return unmarshall(data, ret)
	}

	return nil, fmt.Errorf("%w: %s", ObsRabbitMessageError_UnknownMessageType, ObsMessageType)
}

type ObsMessageProcessor func(topic string, data []byte) error

type RabbitMQObsBuildStatusProcessor struct {
	Handlers map[string]ObsMessageProcessor

	c *RabbitConnection
}

func (o *RabbitMQObsBuildStatusProcessor) routingKeyPrefix() string {
	if strings.HasSuffix(o.c.RabbitURL.Hostname(), "opensuse.org") {
		return "opensuse"
	}

	return "suse"
}

func (o *RabbitMQObsBuildStatusProcessor) GenerateTopics() []string {
	prefix := o.routingKeyPrefix()
	msgs := make([]string, len(o.Handlers))
	idx := 0
	for k, _ := range o.Handlers {
		msgs[idx] = prefix + ".obs." + k
		idx++
	}
	slices.Sort(msgs)
	return msgs
}

func (o *RabbitMQObsBuildStatusProcessor) Connection() *RabbitConnection {
	if o.c == nil {
		o.c = &RabbitConnection{}
	}

	return o.c
}

func (o *RabbitMQObsBuildStatusProcessor) ProcessRabbitMessage(msg RabbitMessage) error {
	prefix := o.routingKeyPrefix() + ".obs."
	topic := strings.TrimPrefix(msg.RoutingKey, prefix)
	if h, ok := o.Handlers[topic]; ok {
		return h(topic, msg.Body)
	}

	return fmt.Errorf("Unhandled message received: %s", msg.RoutingKey)
}