package controller

import (
	"context"
	"errors"
	"time"

	"git.itzana.me/strafesnet/go-grpc/maps_extended"
	"git.itzana.me/strafesnet/maps-service/pkg/model"
	"git.itzana.me/strafesnet/maps-service/pkg/service"
)

var (
	PageError = errors.New("Pagination required")
)

type Maps struct {
	*maps_extended.UnimplementedMapsServiceServer
	inner *service.Service
}

func NewMapsController(
	inner *service.Service,
) Maps {
	return Maps{
		inner: inner,
	}
}

func (svc *Maps) Create(ctx context.Context, request *maps_extended.MapCreate) (*maps_extended.MapId, error) {
	id, err := svc.inner.CreateMap(ctx, model.Map{
		ID:           request.ID,
		DisplayName:  request.DisplayName,
		Creator:      request.Creator,
		GameID:       request.GameID,
		Submitter:    request.Submitter,
		Date:         time.Unix(request.Date, 0),
		Thumbnail:    request.Thumbnail,
		AssetVersion: request.AssetVersion,
		LoadCount:    0,
		Modes:        request.Modes,
	})
	if err != nil {
		return nil, err
	}

	return &maps_extended.MapId{
		ID: id,
	}, nil
}

func (svc *Maps) Delete(ctx context.Context, request *maps_extended.MapId) (*maps_extended.NullResponse, error) {
	err := svc.inner.DeleteMap(ctx, request.ID)
	if err != nil {
		return nil, err
	}
	return &maps_extended.NullResponse{}, nil
}
func (svc *Maps) Get(ctx context.Context, request *maps_extended.MapId) (*maps_extended.MapResponse, error) {
	item, err := svc.inner.GetMap(ctx, request.ID)
	if err != nil {
		return nil, err
	}

	return &maps_extended.MapResponse{
		ID:           item.ID,
		DisplayName:  item.DisplayName,
		Creator:      item.Creator,
		GameID:       uint32(item.GameID),
		Date:         item.Date.Unix(),
		CreatedAt:    item.CreatedAt.Unix(),
		UpdatedAt:    item.UpdatedAt.Unix(),
		Submitter:    uint64(item.Submitter),
		Thumbnail:    uint64(item.Thumbnail),
		AssetVersion: uint64(item.AssetVersion),
		LoadCount:    item.LoadCount,
		Modes:        item.Modes,
	}, nil
}
func (svc *Maps) GetList(ctx context.Context, request *maps_extended.MapIdList) (*maps_extended.MapList, error) {
	items, err := svc.inner.GetMapList(ctx, request.ID)
	if err != nil {
		return nil, err
	}

	resp := maps_extended.MapList{}
	resp.Maps = make([]*maps_extended.MapResponse, len(items))
	for i, item := range items {
		resp.Maps[i] = &maps_extended.MapResponse{
			ID:           item.ID,
			DisplayName:  item.DisplayName,
			Creator:      item.Creator,
			GameID:       uint32(item.GameID),
			Date:         item.Date.Unix(),
			CreatedAt:    item.CreatedAt.Unix(),
			UpdatedAt:    item.UpdatedAt.Unix(),
			Submitter:    uint64(item.Submitter),
			Thumbnail:    uint64(item.Thumbnail),
			AssetVersion: uint64(item.AssetVersion),
			LoadCount:    item.LoadCount,
			Modes:        item.Modes,
		}
	}

	return &resp, nil
}
func (svc *Maps) List(ctx context.Context, request *maps_extended.ListRequest) (*maps_extended.MapList, error) {
	if request.Page == nil {
		return nil, PageError
	}

	filter := service.NewMapFilter()
	if request.Filter != nil {
		if request.Filter.DisplayName != nil {
			filter.SetDisplayName(*request.Filter.DisplayName)
		}
		if request.Filter.Creator != nil {
			filter.SetCreator(*request.Filter.Creator)
		}
		if request.Filter.GameID != nil {
			filter.SetGameID(*request.Filter.GameID)
		}
		if request.Filter.Submitter != nil {
			filter.SetSubmitter(*request.Filter.Submitter)
		}
	}

	items, err := svc.inner.ListMaps(ctx, filter, model.Page{
		Number: int32(request.Page.Number),
		Size:   int32(request.Page.Size),
	})
	if err != nil {
		return nil, err
	}

	resp := maps_extended.MapList{}
	resp.Maps = make([]*maps_extended.MapResponse, len(items))
	for i, item := range items {
		resp.Maps[i] = &maps_extended.MapResponse{
			ID:           item.ID,
			DisplayName:  item.DisplayName,
			Creator:      item.Creator,
			GameID:       uint32(item.GameID),
			Date:         item.Date.Unix(),
			CreatedAt:    item.CreatedAt.Unix(),
			UpdatedAt:    item.UpdatedAt.Unix(),
			Submitter:    uint64(item.Submitter),
			Thumbnail:    uint64(item.Thumbnail),
			AssetVersion: uint64(item.AssetVersion),
			LoadCount:    item.LoadCount,
			Modes:        item.Modes,
		}
	}

	return &resp, nil
}
func (svc *Maps) Update(ctx context.Context, request *maps_extended.MapUpdate) (*maps_extended.NullResponse, error) {
	update := service.NewMapUpdate()
	if request.DisplayName != nil {
		update.SetDisplayName(*request.DisplayName)
	}
	if request.Creator != nil {
		update.SetCreator(*request.Creator)
	}
	if request.GameID != nil {
		update.SetGameID(*request.GameID)
	}
	if request.Date != nil {
		update.SetDate(*request.Date)
	}
	if request.Submitter != nil {
		update.SetSubmitter(*request.Submitter)
	}
	if request.Thumbnail != nil {
		update.SetThumbnail(*request.Thumbnail)
	}
	if request.AssetVersion != nil {
		update.SetAssetVersion(*request.AssetVersion)
	}
	if request.Modes != nil {
		update.SetModes(*request.Modes)
	}

	err := svc.inner.UpdateMap(ctx, request.ID, update)
	if err != nil {
		return nil, err
	}
	return &maps_extended.NullResponse{}, nil
}

func (svc *Maps) IncrementLoadCount(ctx context.Context, request *maps_extended.MapId) (*maps_extended.NullResponse, error) {
	err := svc.inner.IncrementMapLoadCount(ctx, request.ID)
	if err != nil {
		return nil, err
	}
	return &maps_extended.NullResponse{}, nil
}

func (svc *Maps) GetSnfmDownloadUrl(ctx context.Context, request *maps_extended.MapId) (*maps_extended.SnfmDownloadUrl, error) {
	url, err := svc.inner.GetSnfmDownloadUrl(ctx, request.ID)
	if err != nil {
		return nil, err
	}
	return &maps_extended.SnfmDownloadUrl{
		Url: url,
	}, nil
}