package core

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"

	"github.com/go-redis/redis/v8"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"github.com/gorilla/websocket"
	"repositories.action2quare.com/ayo/gocommon"
	"repositories.action2quare.com/ayo/gocommon/logger"
	"repositories.action2quare.com/ayo/gocommon/wshandler"
)

type channelID = string
type channelConfig struct {
	Capacity  int64  `json:"capacity"`
	Size      int64  `json:"size"`
	Key       string `json:"key"`
	emptyJson string
}

type chatConfig struct {
	DefaultCapacity int64                     `json:"default_capacity"`
	Channels        map[string]*channelConfig `json:"channels"`
}

type groupChat struct {
	chatConfig
	rh                  *gocommon.RedisonHandler
	enterRoom           func(channelID, accountID)
	leaveRoom           func(channelID, accountID)
	sendUpstreamMessage func(msg *wshandler.UpstreamMessage)
}

func (gc *groupChat) Initialize(tv *Tavern, cfg configDocument) error {
	rem, _ := json.Marshal(cfg)
	if err := json.Unmarshal(rem, &gc.chatConfig); err != nil {
		return err
	}

	gc.enterRoom = func(chanid channelID, accid accountID) {
		tv.wsh.EnterRoom(string(chanid), accid)
	}
	gc.leaveRoom = func(chanid channelID, accid accountID) {
		tv.wsh.LeaveRoom(string(chanid), accid)
	}
	gc.sendUpstreamMessage = func(msg *wshandler.UpstreamMessage) {
		tv.wsh.SendUpstreamMessage(msg)
	}

	gc.rh = tv.redison

	for name, cfg := range gc.chatConfig.Channels {
		if cfg.Capacity == 0 {
			cfg.Capacity = gc.chatConfig.DefaultCapacity
		}
		cfg.Key = name
		cfg.Size = 0

		jm, _ := json.Marshal(cfg)
		cfg.emptyJson = fmt.Sprintf("[%s]", string(jm))

		_, err := gc.rh.JSONSet(name, "$", cfg)
		if *devflag && err != nil {
			gc.rh.JSONDel(name, "$")
			_, err = gc.rh.JSONSet(name, "$", cfg)
		}

		if err != nil {
			return err
		}
	}

	return nil
}

func (gc *groupChat) ClientConnected(conn *websocket.Conn, callby *wshandler.Sender) {
	gc.rh.JSONSet(callby.Accid.Hex(), "$.channel", map[string]any{})
}

func (gc *groupChat) ClientDisconnected(conn *websocket.Conn, callby *wshandler.Sender) {
	docs, _ := gc.rh.JSONGetDocuments(callby.Accid.Hex(), "$.channel")

	if len(docs) > 0 {
		for k, v := range docs[0] {
			typename := k
			chanid := v.(string)
			gc.leaveRoom(chanid, callby.Accid)
			if k == "public" {
				gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
			} else {
				gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
					Target: "#" + chanid,
					Body:   map[string]any{"sender": callby.Alias},
					Tag:    []string{typename + ".LeavePrivateChannel"},
				})
			}
		}
	}
}

func (gc *groupChat) EnterPublicChannel(ctx wshandler.ApiCallContext) {
	chanid := ctx.Arguments[0].(string)
	if cfg, ok := gc.chatConfig.Channels[chanid]; ok {
		size, err := gc.rh.JSONGetInt64(chanid, "$.size")
		if err != nil || len(size) == 0 {
			logger.Println("JSONGetInt64 failed :", chanid, err)
		} else if size[0] < cfg.Capacity {
			// 입장
			newsize, err := gc.rh.JSONNumIncrBy(chanid, "$.size", 1)
			if err == nil {
				gc.enterRoom(chanid, ctx.CallBy.Accid)
				gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel.public", chanid)
				gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
					Target: "#" + chanid,
					Body:   map[string]any{"size": newsize[0]},
					Tag:    []string{"ChattingChannelProperties"},
				})
			}
		} else {
			// 풀방
			logger.Println("chatting channel is full :", chanid, size, cfg.Capacity)
		}
	} else {
		logger.Println("chatting channel not valid :", chanid)
	}
}

func (gc *groupChat) LeavePublicChannel(ctx wshandler.ApiCallContext) {
	chanid := ctx.Arguments[0].(string)
	cnt, _ := gc.rh.JSONDel(ctx.CallBy.Accid.Hex(), "$.channel.public")
	if cnt > 0 {
		gc.leaveRoom(chanid, ctx.CallBy.Accid)
		gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
	}
}

func (gc *groupChat) TextMessage(ctx wshandler.ApiCallContext) {
	chanid := ctx.Arguments[0].(string)
	msg := ctx.Arguments[1].(string)
	gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
		Target: "#" + chanid,
		Body:   map[string]any{"sender": ctx.CallBy.Alias, "msg": msg},
		Tag:    []string{"TextMessage"},
	})
}

func (gc *groupChat) EnterPrivateChannel(ctx wshandler.ApiCallContext) {
	typename := ctx.Arguments[0].(string)
	channel := ctx.Arguments[1].(string)
	var reason string
	if len(ctx.Arguments) > 2 {
		reason = ctx.Arguments[2].(string)
	}

	if len(reason) > 0 {
		// 수락
		ok, err := gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel."+typename, channel, gocommon.RedisonSetOptionNX)
		if err != nil || !ok {
			// 이미 다른 private channel 참여 중
			logger.Println("EnterPrivateChannel failed. HSetNX return err :", err, ctx.CallBy.Accid.Hex(), typename, channel)
			return
		}
		gc.enterRoom(channel, ctx.CallBy.Accid)
	}

	gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
		Target: "#" + channel,
		Body: map[string]any{
			"sender": ctx.CallBy.Alias,
			"msg":    reason,
		},
		Tag: []string{typename + ".EnterPrivateChannel"},
	})
}

func (gc *groupChat) LeavePrivateChannel(ctx wshandler.ApiCallContext) {
	typename := ctx.Arguments[0].(string)
	chanid := ctx.Arguments[1].(string)
	cnt, _ := gc.rh.JSONDel(ctx.CallBy.Accid.Hex(), "$.channel."+typename)
	if cnt > 0 {
		gc.leaveRoom(chanid, ctx.CallBy.Accid)
		gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
			Target: "#" + chanid,
			Body:   map[string]any{"sender": ctx.CallBy.Alias},
			Tag:    []string{typename + ".LeavePrivateChannel"},
		})
	}
}

func (gc *groupChat) FetchChattingChannels(w http.ResponseWriter, r *http.Request) {
	var prefix string
	if err := gocommon.MakeDecoder(r).Decode(&prefix); err != nil {
		logger.Println("FetchChattingChannels failed. ReadJsonDocumentFromBody returns err :", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	if len(prefix) == 0 {
		logger.Println("FetchChattingChannel failed. prefix is missing")
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var rows []string
	for name, cfg := range gc.chatConfig.Channels {
		if len(prefix) > 0 {
			if !strings.HasPrefix(name, prefix) {
				continue
			}
		}

		onechan, err := gc.rh.JSONGet(name, "$")
		if err != nil && err != redis.Nil {
			logger.Println("FetchChattingChannel failed. HGetAll return err :", err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		if err == redis.Nil || onechan == nil {
			rows = append(rows, cfg.emptyJson)
		} else {
			// json array로 나온다
			rows = append(rows, strings.Trim(onechan.(string), "[]"))
		}
	}

	gocommon.MakeEncoder(w, r).Encode(rows)
}

func (gc *groupChat) QueryPlayerChattingChannel(w http.ResponseWriter, r *http.Request) {
	var accid primitive.ObjectID
	if err := gocommon.MakeDecoder(r).Decode(&accid); err != nil {
		logger.Println("QueryPlayerChattingChannel failed. ReadJsonDocumentFromBody returns err :", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	sub, err := gc.rh.JSONGetDocuments(accid.Hex(), "$.channel")
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	if len(sub) > 0 {
		gocommon.MakeEncoder(w, r).Encode(sub[0])
	}
}

func (gc *groupChat) SendMessageOnChannel(w http.ResponseWriter, r *http.Request) {
	var msg wshandler.UpstreamMessage
	if err := gocommon.MakeDecoder(r).Decode(&msg); err != nil {
		logger.Println("SendMessageOnChannel failed. ReadJsonDocumentFromBody return err :", err)
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	gc.sendUpstreamMessage(&msg)
}