package httpRequest

import (
	"net/http"
	"time"

	"go-socket/packages/cache"
	"go-socket/packages/postgresql"
	"go-socket/packages/types"

	"github.com/google/uuid"
)

func hasHubUserPermission(user *types.HubUser, hub *types.Hub, permission types.RolePermission) bool {
	for _, roleId := range user.Roles {
		if role, ok := hub.Roles[roleId]; ok && role.HasPermission(permission) {
			return true
		}
	}
	return false
}

func HandleHubCreate(response http.ResponseWriter, request *http.Request) {
	if !validCheckWithResponseOnFail(&response, request, normal) {
		return
	}

	ctx := request.Context()
	user, err := getUserByToken(ctx, request.Header.Get("token"))
	if err != nil {
		http.Error(response, "invalid token", http.StatusUnauthorized)
		return
	}

	hubName := request.Header.Get("hubname")
	if hubName == "" {
		http.Error(response, "hub name is required", http.StatusBadRequest)
		return
	}

	hub := types.NewHub()
	hub.Name = hubName
	hub.Creator = user.Id
	hub.Color = types.Rgba{}.GetRandom()
	hub.CreatedAt = time.Now()

	rootGrp := &types.HubChannelGroup{
		Id:       uuid.New(),
		Name:     "root",
		Color:    types.Rgba{6, 2, 1, 255},
		Position: uint8(0),
	}
	hub.ChannelGroups[rootGrp.Id] = rootGrp

	rootRole := &types.HubRole{
		Id:             0,
		Name:           "root",
		Color:          types.Rgba{255, 0, 0, 255},
		RolePermission: ^types.RolePermission(0),
	}
	hub.Roles[rootRole.Id] = rootRole

	rootUser := &types.HubUser{
		Id:        user.Id,
		Username:  user.Name,
		Roles:     []uint8{rootRole.Id},
		CreatedAt: hub.CreatedAt,
	}
	hub.Users[rootUser.Id] = rootUser

	err = postgresql.HubSave(ctx, hub)
	if err != nil {
		http.Error(response, "internal server error", http.StatusInternalServerError)
		return
	}
	if err = postgresql.HubRoleSave(ctx, hub.Id, rootRole); err != nil {
		http.Error(response, "internal server error", http.StatusInternalServerError)
		return
	}
	if err = postgresql.HubChannelGroupSave(ctx, hub.Id, rootGrp); err != nil {
		http.Error(response, "internal server error", http.StatusInternalServerError)
		return
	}
	if err = postgresql.HubUserAdd(ctx, hub.Id, rootUser); err != nil {
		http.Error(response, "internal server error", http.StatusInternalServerError)
		return
	}
	if err = postgresql.HubUserRoleAdd(ctx, hub.Id, user.Id, rootRole.Id); err != nil {
		http.Error(response, "internal server error", http.StatusInternalServerError)
		return
	}
	cache.SaveHub(hub)

	response.WriteHeader(http.StatusCreated)
	response.Write([]byte(hub.Id.String()))
}

func HandleHubDelete(response http.ResponseWriter, request *http.Request) {
	if !validCheckWithResponseOnFail(&response, request, normal) {
		return
	}
	ctx := request.Context()

	_, hubUser, hub, err := getHubUserIfValidWithResponseOnFail(ctx, response, request.Header.Get("token"), request.Header.Get("hubid"))
	if err != nil {
		return
	}

	if !hasHubUserPermission(hubUser, hub, types.PermissionRemoveHub) {
		http.Error(response, "forbidden", http.StatusForbidden)
		return
	}

	if err := postgresql.HubDelete(ctx, hub); err != nil {
		http.Error(response, "internal server error", http.StatusInternalServerError)
		return
	}
	cache.DeleteHub(hub)

	response.WriteHeader(http.StatusOK)
}

func HandleHubGet(response http.ResponseWriter, request *http.Request) {
	if !validCheckWithResponseOnFail(&response, request, normal) {
		return
	}
	ctx := request.Context()
	_, _, hub, err := getHubUserIfValidWithResponseOnFail(ctx, response, request.Header.Get("token"), request.Header.Get("hubid"))
	if err != nil {
		return
	}
	
}