package controller

import (
	"context"

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

type Mapfixes struct {
	*mapfixes.UnimplementedMapfixesServiceServer
	inner *service.Service
}

func NewMapfixesController(
	inner *service.Service,
) Mapfixes {
	return Mapfixes{
		inner: inner,
	}
}

func (svc *Mapfixes) Get(ctx context.Context, request *mapfixes.MapfixId) (*mapfixes.MapfixResponse, error) {
	item, err := svc.inner.GetMapfix(ctx, request.ID)
	if err != nil {
		return nil, err
	}

	var validated_asset_id *uint64
	if item.ValidatedAssetID != 0 {
		validated_asset_id = &item.ValidatedAssetID
	}
	var validated_asset_version *uint64
	if item.ValidatedAssetVersion != 0 {
		validated_asset_version = &item.ValidatedAssetVersion
	}
	return &mapfixes.MapfixResponse{
		ID:                    item.ID,
		DisplayName:           item.DisplayName,
		Creator:               item.Creator,
		GameID:                uint32(item.GameID),
		CreatedAt:             item.CreatedAt.Unix(),
		UpdatedAt:             item.UpdatedAt.Unix(),
		Submitter:             uint64(item.Submitter),
		AssetVersion:          uint64(item.AssetVersion),
		AssetID:               item.AssetID,
		ValidatedAssetID:      validated_asset_id,
		ValidatedAssetVersion: validated_asset_version,
		TargetAssetID:         item.TargetAssetID,
		StatusID:              mapfixes.MapfixStatus(item.StatusID),
	}, nil
}
func (svc *Mapfixes) GetList(ctx context.Context, request *mapfixes.MapfixIdList) (*mapfixes.MapfixList, error) {
	items, err := svc.inner.GetMapfixList(ctx, request.ID)
	if err != nil {
		return nil, err
	}

	resp := mapfixes.MapfixList{}
	resp.Mapfixes = make([]*mapfixes.MapfixResponse, len(items))
	for i, item := range items {
		var validated_asset_id *uint64
		if item.ValidatedAssetID != 0 {
			validated_asset_id = &item.ValidatedAssetID
		}
		var validated_asset_version *uint64
		if item.ValidatedAssetVersion != 0 {
			validated_asset_version = &item.ValidatedAssetVersion
		}
		resp.Mapfixes[i] = &mapfixes.MapfixResponse{
			ID:                    item.ID,
			DisplayName:           item.DisplayName,
			Creator:               item.Creator,
			GameID:                uint32(item.GameID),
			CreatedAt:             item.CreatedAt.Unix(),
			UpdatedAt:             item.UpdatedAt.Unix(),
			Submitter:             uint64(item.Submitter),
			AssetVersion:          uint64(item.AssetVersion),
			AssetID:               item.AssetID,
			ValidatedAssetID:      validated_asset_id,
			ValidatedAssetVersion: validated_asset_version,
			TargetAssetID:         item.TargetAssetID,
			StatusID:              mapfixes.MapfixStatus(item.StatusID),
		}
	}

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

	filter := service.NewMapfixFilter()
	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.ListMapfixes(ctx, filter, model.Page{
		Number: int32(request.Page.Number),
		Size:   int32(request.Page.Size),
	}, datastore.ListSortDateDescending)
	if err != nil {
		return nil, err
	}

	resp := mapfixes.MapfixList{}
	resp.Mapfixes = make([]*mapfixes.MapfixResponse, len(items))
	for i, item := range items {
		var validated_asset_id *uint64
		if item.ValidatedAssetID != 0 {
			validated_asset_id = &item.ValidatedAssetID
		}
		var validated_asset_version *uint64
		if item.ValidatedAssetVersion != 0 {
			validated_asset_version = &item.ValidatedAssetVersion
		}
		resp.Mapfixes[i] = &mapfixes.MapfixResponse{
			ID:                    item.ID,
			DisplayName:           item.DisplayName,
			Creator:               item.Creator,
			GameID:                uint32(item.GameID),
			CreatedAt:             item.CreatedAt.Unix(),
			UpdatedAt:             item.UpdatedAt.Unix(),
			Submitter:             uint64(item.Submitter),
			AssetVersion:          uint64(item.AssetVersion),
			AssetID:               item.AssetID,
			ValidatedAssetID:      validated_asset_id,
			ValidatedAssetVersion: validated_asset_version,
			TargetAssetID:         item.TargetAssetID,
			StatusID:              mapfixes.MapfixStatus(item.StatusID),
		}
	}

	return &resp, nil
}