package ws

import (
	"context"
	"fmt"

	"lone-services/pkg/redis"

	jsoniter "github.com/json-iterator/go"
)

func Publish(ctx context.Context, sessionID string, resp Response) error {
	if redis.Client == nil {
		return fmt.Errorf("ws: redis not initialized")
	}
	if sessionID == "" {
		return fmt.Errorf("ws: session_id empty")
	}

	var dataRaw []byte
	if resp.Data != nil {
		b, err := jsoniter.Marshal(resp.Data)
		if err != nil {
			return err
		}
		dataRaw = b
	}

	evt := Event{
		SessionID: sessionID,
		Code:      resp.Code,
		Message:   resp.Message,
		Data:      dataRaw,
	}
	payload, err := jsoniter.Marshal(evt)
	if err != nil {
		return err
	}
	return redis.Client.Publish(ctx, RedisChannelQRPush, payload).Err()
}

func UpdateSessionAndPublish(ctx context.Context, sessionID string, status int, data interface{}) error {
	if redis.Client == nil {
		return fmt.Errorf("ws: redis not initialized")
	}
	if sessionID == "" {
		return fmt.Errorf("ws: session_id empty")
	}

	sess := Session{Status: status}
	if old, err := GetSession(ctx, sessionID); err == nil && old != nil {
		sess.ClientCode = old.ClientCode
	}
	if data != nil {
		b, err := jsoniter.Marshal(data)
		if err != nil {
			return err
		}
		sess.Data = b
	}

	raw, err := jsoniter.Marshal(sess)
	if err != nil {
		return err
	}
	key := RedisKeyQRSession + sessionID
	if err := redis.Client.Set(ctx, key, raw, SessionTTL).Err(); err != nil {
		return err
	}
	return Publish(ctx, sessionID, Success(data))
}

func GetSession(ctx context.Context, sessionID string) (*Session, error) {
	if redis.Client == nil {
		return nil, fmt.Errorf("ws: redis not initialized")
	}
	if sessionID == "" {
		return nil, fmt.Errorf("ws: session_id empty")
	}

	val, err := redis.Client.Get(ctx, RedisKeyQRSession+sessionID).Result()
	if err != nil {
		return nil, err
	}
	var sess Session
	if err := jsoniter.UnmarshalFromString(val, &sess); err != nil {
		return nil, err
	}
	return &sess, nil
}