package service_internal

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"

	"git.itzana.me/strafesnet/maps-service/pkg/datastore"
	internal "git.itzana.me/strafesnet/maps-service/pkg/internal"
	"git.itzana.me/strafesnet/maps-service/pkg/model"
)

var(
	// prevent two mapfixes with same asset id
	ActiveMapfixStatuses = []model.MapfixStatus{
		model.MapfixStatusUploading,
		model.MapfixStatusValidated,
		model.MapfixStatusValidating,
		model.MapfixStatusAcceptedUnvalidated,
		model.MapfixStatusChangesRequested,
		model.MapfixStatusSubmitted,
		model.MapfixStatusUnderConstruction,
	}
)

var(
	ErrActiveMapfixSameAssetID = errors.New("There is an active mapfix with the same AssetID")
	ErrNotAssetOwner = errors.New("You can only submit an asset you own")
)

// UpdateMapfixValidatedModel implements patchMapfixModel operation.
//
// Update model following role restrictions.
//
// POST /mapfixes/{MapfixID}/validated-model
func (svc *Service) UpdateMapfixValidatedModel(ctx context.Context, params internal.UpdateMapfixValidatedModelParams) error {
	ValidatedModelID := uint64(params.ValidatedModelID)
	ValidatedModelVersion := uint64(params.ValidatedModelVersion)

	// check if Status is ChangesRequested|Submitted|UnderConstruction
	pmap := datastore.Optional()
	pmap.Add("validated_asset_id", ValidatedModelID)
	pmap.Add("validated_asset_version", ValidatedModelVersion)
	// DO NOT reset completed when validated model is updated
	// pmap.Add("completed", false)
	err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, pmap)
	if err != nil {
		return err
	}

	event_data := model.AuditEventDataChangeValidatedModel{
		ValidatedModelID: ValidatedModelID,
		ValidatedModelVersion: ValidatedModelVersion,
	}

	EventData, err := json.Marshal(event_data)
	if err != nil {
		return err
	}

	_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
		ID:           0,
		User:         ValidtorUserID,
		ResourceType: model.ResourceMapfix,
		ResourceID:   params.MapfixID,
		EventType:    model.AuditEventTypeChangeValidatedModel,
		EventData:    EventData,
	})
	if err != nil {
		return err
	}

	return nil
}

// ActionMapfixSubmitted invokes actionMapfixSubmitted operation.
//
// Role Validator changes status from Submitting -> Submitted.
//
// POST /mapfixes/{MapfixID}/status/validator-submitted
func (svc *Service) ActionMapfixSubmitted(ctx context.Context, params internal.ActionMapfixSubmittedParams) error {
	// transaction
	target_status := model.MapfixStatusSubmitted
	smap := datastore.Optional()
	smap.Add("status_id", target_status)
	smap.Add("asset_version", params.ModelVersion)
	err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitting}, smap)
	if err != nil {
		return err
	}

	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	EventData, err := json.Marshal(event_data)
	if err != nil {
		return err
	}

	_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
		ID:           0,
		User:         ValidtorUserID,
		ResourceType: model.ResourceMapfix,
		ResourceID:   params.MapfixID,
		EventType:    model.AuditEventTypeAction,
		EventData:    EventData,
	})
	if err != nil {
		return err
	}

	return nil
}

// ActionMapfixRequestChanges implements actionMapfixRequestChanges operation.
//
// (Internal endpoint) Role Validator changes status from Submitting -> RequestChanges.
//
// POST /mapfixes/{MapfixID}/status/validator-request-changes
func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params internal.ActionMapfixRequestChangesParams) error {
	// transaction
	target_status := model.MapfixStatusChangesRequested
	smap := datastore.Optional()
	smap.Add("status_id", target_status)
	err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitting}, smap)
	if err != nil {
		return err
	}

	{
		event_data := model.AuditEventDataError{
			Error: params.ErrorMessage,
		}

		EventData, err := json.Marshal(event_data)
		if err != nil {
			return err
		}

		_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
			ID:           0,
			User:         ValidtorUserID,
			ResourceType: model.ResourceMapfix,
			ResourceID:   params.MapfixID,
			EventType:    model.AuditEventTypeError,
			EventData:    EventData,
		})
		if err != nil {
			return err
		}
	}

	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	EventData, err := json.Marshal(event_data)
	if err != nil {
		return err
	}

	_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
		ID:           0,
		User:         ValidtorUserID,
		ResourceType: model.ResourceMapfix,
		ResourceID:   params.MapfixID,
		EventType:    model.AuditEventTypeAction,
		EventData:    EventData,
	})
	if err != nil {
		return err
	}

	return nil
}

// ActionMapfixValidate invokes actionMapfixValidate operation.
//
// Role Validator changes status from Validating -> Validated.
//
// POST /mapfixes/{MapfixID}/status/validator-validated
func (svc *Service) ActionMapfixValidated(ctx context.Context, params internal.ActionMapfixValidatedParams) error {
	// transaction
	smap := datastore.Optional()
	smap.Add("status_id", model.MapfixStatusValidated)
	return svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, smap)
}

// ActionMapfixAccepted implements actionMapfixAccepted operation.
//
// (Internal endpoint) Role Validator changes status from Validating -> Accepted.
//
// POST /mapfixes/{MapfixID}/status/validator-failed
func (svc *Service) ActionMapfixAccepted(ctx context.Context, params internal.ActionMapfixAcceptedParams) error {
	// transaction
	target_status := model.MapfixStatusAcceptedUnvalidated
	smap := datastore.Optional()
	smap.Add("status_id", target_status)
	err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, smap)
	if err != nil {
		return err
	}

	//push an error audit event
	{
		event_data := model.AuditEventDataError{
			Error: params.ErrorMessage,
		}

		EventData, err := json.Marshal(event_data)
		if err != nil {
			return err
		}

		_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
			ID:           0,
			User:         ValidtorUserID,
			ResourceType: model.ResourceMapfix,
			ResourceID:   params.MapfixID,
			EventType:    model.AuditEventTypeError,
			EventData:    EventData,
		})
		if err != nil {
			return err
		}
	}

	// push an action audit event
	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	EventData, err := json.Marshal(event_data)
	if err != nil {
		return err
	}

	_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
		ID:           0,
		User:         ValidtorUserID,
		ResourceType: model.ResourceMapfix,
		ResourceID:   params.MapfixID,
		EventType:    model.AuditEventTypeAction,
		EventData:    EventData,
	})
	if err != nil {
		return err
	}

	return nil
}

// ActionMapfixUploaded implements actionMapfixUploaded operation.
//
// (Internal endpoint) Role Validator changes status from Uploading -> Uploaded.
//
// POST /mapfixes/{MapfixID}/status/validator-uploaded
func (svc *Service) ActionMapfixUploaded(ctx context.Context, params internal.ActionMapfixUploadedParams) error {
	// transaction
	target_status := model.MapfixStatusUploaded
	smap := datastore.Optional()
	smap.Add("status_id", target_status)
	err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusUploading}, smap)
	if err != nil {
		return err
	}

	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	EventData, err := json.Marshal(event_data)
	if err != nil {
		return err
	}

	_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
		ID:           0,
		User:         ValidtorUserID,
		ResourceType: model.ResourceMapfix,
		ResourceID:   params.MapfixID,
		EventType:    model.AuditEventTypeAction,
		EventData:    EventData,
	})
	if err != nil {
		return err
	}

	return nil
}

// POST /mapfixes
func (svc *Service) CreateMapfix(ctx context.Context, request *internal.MapfixCreate) (*internal.MapfixID, error) {
	// sanitization
	if request.GameID<0||
	request.AssetOwner<0||
	request.AssetID<0||
	request.AssetVersion<0||
	request.TargetAssetID<0{
		return nil, ErrNegativeID
	}
	var GameID=uint32(request.GameID);
	var Submitter=uint64(request.AssetOwner);
	var AssetID=uint64(request.AssetID);
	var AssetVersion=uint64(request.AssetVersion);
	var TargetAssetID=uint64(request.TargetAssetID);

	// Check if an active mapfix with the same asset id exists
	{
		filter := datastore.Optional()
		filter.Add("asset_id", request.AssetID)
		filter.Add("asset_version", request.AssetVersion)
		filter.Add("status_id", ActiveMapfixStatuses)
		active_mapfixes, err := svc.DB.Mapfixes().List(ctx, filter, model.Page{
			Number: 1,
			Size:   1,
		},datastore.ListSortDisabled)
		if err != nil {
			return nil, err
		}
		if len(active_mapfixes) != 0{
			return nil, ErrActiveMapfixSameAssetID
		}
	}

	operation, err := svc.DB.Operations().Get(ctx, request.OperationID)
	if err != nil {
		return nil, err
	}

	// check if user owns asset
	// TODO: allow bypass by admin
	if operation.Owner != Submitter {
		return nil, ErrNotAssetOwner
	}

	mapfix, err := svc.DB.Mapfixes().Create(ctx, model.Mapfix{
		ID:            0,
		DisplayName:   request.DisplayName,
		Creator:       request.Creator,
		GameID:        GameID,
		Submitter:     Submitter,
		AssetID:       AssetID,
		AssetVersion:  AssetVersion,
		Completed:     false,
		TargetAssetID: TargetAssetID,
		StatusID:      model.MapfixStatusUnderConstruction,
		Description:   request.Description,
	})
	if err != nil {
		return nil, err
	}

	// mark the operation as completed and provide the path
	pmap := datastore.Optional()
	pmap.Add("status_id", model.OperationStatusCompleted)
	pmap.Add("path", fmt.Sprintf("/mapfixes/%d", mapfix.ID))
	err = svc.DB.Operations().Update(ctx, request.OperationID, pmap)
	if err != nil {
		return nil, err
	}

	return &internal.MapfixID{
		MapfixID: mapfix.ID,
	}, nil
}