package msgdata

import (
	"encoding/json"
	"errors"
	"fmt"

	"edge-infra.dev/pkg/sds/emergencyaccess/apierror"
	"edge-infra.dev/pkg/sds/emergencyaccess/eaconst"
)

type v1_0Request struct {
	ReqAttr map[string]string `json:"attributes"`
	ReqData v1Data            `json:"data"`
	command string
}

type v1Data struct {
	Command string `json:"command"`
}

// Create a structured v1.0 request from a full command string
func NewV1_0Request(payload string) (Request, error) {
	name, _, err := parsePayload(payload)
	if err != nil {
		return nil, apierror.E(apierror.ErrInvalidCommand, err)
	}
	req := v1_0Request{
		ReqData: v1Data{
			Command: payload,
		},
		ReqAttr: map[string]string{
			eaconst.VersionKey:     string(eaconst.MessageVersion1_0),
			eaconst.RequestTypeKey: string(eaconst.Command),
		},
		command: name,
	}
	if err := req.validate(); err != nil {
		return nil, err
	}
	return req, nil
}

func (v v1_0Request) AddAttribute(key, val string) {
	if _, ok := v.ReqAttr[key]; !ok {
		v.ReqAttr[key] = val
	}
}

func (v v1_0Request) Attributes() map[string]string {
	return deepCopyMap(v.ReqAttr)
}

func (v v1_0Request) CommandToBeAuthorized() string {
	return v.command
}

func (v v1_0Request) Data() ([]byte, error) {
	return json.Marshal(v.ReqData)
}

func (v v1_0Request) RequestType() eaconst.RequestType {
	return eaconst.Command
}

func (v v1_0Request) validate() error {
	var err error
	var apiErr error
	if v.ReqData.Command == "" {
		err = errors.Join(err, errors.New("command and args are empty"))
	}
	if v.command == "" {
		apiErr = apierror.E(apierror.ErrInvalidCommand, "No command identified")
		err = errors.Join(err, errors.New("command is empty"))
	}
	if attrErr := validateAttributes(v.ReqAttr, string(eaconst.MessageVersion1_0), string(eaconst.Command)); attrErr != nil {
		err = errors.Join(err, attrErr)
	}
	if err != nil {
		return apierror.E(apierror.ErrInvalidCommand, apiErr, err)
	}
	return nil
}

func assembleV1_0Request(data []byte, attributes map[string]string) (Request, error) {
	var reqData v1Data
	err := json.Unmarshal(data, &reqData)
	if err != nil {
		return nil, fmt.Errorf("failed to unmarshal: %w", err)
	}
	name, _, err := parsePayload(reqData.Command)
	if err != nil {
		return nil, apierror.E(apierror.ErrInvalidCommand, err)
	}
	req := v1_0Request{
		ReqData: reqData,
		ReqAttr: deepCopyMap(attributes),
		command: name,
	}
	if err := req.validate(); err != nil {
		return nil, err
	}
	return req, nil
}