package controller

import (
	"context"
	"time"

	"git.tek.govt.hu/dowerx/chat/server/dao"
	"git.tek.govt.hu/dowerx/chat/server/model"
	"git.tek.govt.hu/dowerx/chat/server/util"
)

type ChatController struct {
	channelDAO     dao.IChannelDAO
	sessionDAO     dao.ISessionDAO
	messageDAO     dao.IMessageDAO
	notifcationDAO dao.INotificationDAO
	userDAO        dao.IUserDAO
	rightDAO       dao.IRightDAO
}

func (c ChatController) ListAvailableChannels(userID int) ([]model.Channel, *util.ChatError) {
	return c.channelDAO.ListAvailableChannels(userID)
}

func (c ChatController) GetMessages(userID int, channel int, from time.Time, limit int) ([]model.Message, *util.ChatError) {
	rights, err := c.rightDAO.ListUserRigths(model.User{ID: userID})
	if err != nil {
		return nil, err
	}

	right, ok := rights[channel]
	if !ok {
		return nil, &util.ChatError{Message: "", Code: util.SEND_NOT_AUTHORIZED}
	}

	switch right {
	case model.RightWrite:
		return nil, &util.ChatError{Message: "", Code: util.SEND_NOT_AUTHORIZED}
	case model.RightReadWrite:
		break
	case model.RightAdmin:
		break
	case model.RightRead:
		break
	}

	return c.messageDAO.List(model.Channel{ID: channel}, from, limit)
}

func (c ChatController) SendMessage(userID int, channel int, content string) *util.ChatError {
	user, err := c.userDAO.Read(model.User{ID: userID})
	if err != nil {
		return err
	}

	rights, err := c.rightDAO.ListUserRigths(user)
	if err != nil {
		return err
	}

	right, ok := rights[channel]
	if !ok {
		return &util.ChatError{Message: "", Code: util.SEND_NOT_AUTHORIZED}
	}

	switch right {
	case model.RightWrite:
		break
	case model.RightReadWrite:
		break
	case model.RightAdmin:
		break
	case model.RightRead:
		return &util.ChatError{Message: "", Code: util.SEND_NOT_AUTHORIZED}
	}

	message := model.Message{
		SenderID:   user.ID,
		SenderName: user.Username,
		Channel:    channel,
		Time:       time.Now().UTC(),
		Content:    content,
	}

	message.ID, err = c.messageDAO.Create(message)
	if err != nil {
		return err
	}

	return c.notifcationDAO.SendMessage(message)
}

func (c ChatController) SubscribeToChannel(ctx context.Context, channel int, userID int) (<-chan model.Message, <-chan *util.ChatError) {

	rights, err := c.rightDAO.ListUserRigths(model.User{ID: userID})
	if err != nil {
		errs := make(chan *util.ChatError, 1)
		errs <- err
		return nil, errs
	}

	right, ok := rights[channel]
	if !ok {
		errs := make(chan *util.ChatError, 1)
		errs <- &util.ChatError{Message: "", Code: util.SEND_NOT_AUTHORIZED}
		return nil, errs
	}

	switch right {
	case model.RightWrite:
		errs := make(chan *util.ChatError, 1)
		errs <- &util.ChatError{Message: "", Code: util.SEND_NOT_AUTHORIZED}
		return nil, errs
	case model.RightReadWrite:
		break
	case model.RightAdmin:
		break
	case model.RightRead:
		break
	}

	return c.notifcationDAO.SubscribeToChannel(ctx, channel)
}

func MakeChatController(
	channelDAO dao.IChannelDAO,
	sessionDAO dao.ISessionDAO,
	messageDAO dao.IMessageDAO,
	notificationDAO dao.INotificationDAO,
	userDAO dao.IUserDAO,
	rightDAO dao.IRightDAO) ChatController {
	controller := ChatController{
		channelDAO:     channelDAO,
		sessionDAO:     sessionDAO,
		messageDAO:     messageDAO,
		notifcationDAO: notificationDAO,
		userDAO:        userDAO,
		rightDAO:       rightDAO,
	}
	return controller
}