package web_api

import (
	"context"

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

// CreateScriptPolicy implements createScriptPolicy operation.
//
// Create a new script policy.
//
// POST /script-policy
func (svc *Service) CreateScriptPolicy(ctx context.Context, req *api.ScriptPolicyCreate) (*api.ScriptPolicyID, error) {
	err := CheckHasRoleScriptWrite(ctx)
	if err != nil {
		return nil, err
	}

	from_script, err := svc.inner.GetScript(ctx, req.FromScriptID)
	if err != nil {
		return nil, err
	}

	// the existence of ToScriptID does not need to be validated because it's checked by a foreign key constraint.

	script, err := svc.inner.CreateScriptPolicy(ctx, model.ScriptPolicy{
		ID:             0,
		FromScriptHash: from_script.Hash,
		ToScriptID:     req.ToScriptID,
		Policy:         model.Policy(req.Policy),
	})
	if err != nil {
		return nil, err
	}

	return &api.ScriptPolicyID{
		ScriptPolicyID: script.ID,
	}, nil
}


// ListScriptPolicy implements listScriptPolicy operation.
//
// Get list of script policies.
//
// GET /script-policy
func (svc *Service) ListScriptPolicy(ctx context.Context, params api.ListScriptPolicyParams) ([]api.ScriptPolicy, error) {
	filter := service.NewScriptPolicyFilter()

	if hash_hex, ok := params.FromScriptHash.Get(); ok{
		hash_parsed, err := model.HashParse(hash_hex)
		if err != nil {
			return nil, err
		}
		filter.SetFromScriptHash(int64(hash_parsed))
	}
	if to_script_id, to_script_id_ok := params.ToScriptID.Get(); to_script_id_ok{
		filter.SetToScriptID(to_script_id)
	}
	if policy, policy_ok := params.Policy.Get(); policy_ok{
		filter.SetPolicy(policy)
	}


	items, err := svc.inner.ListScriptPolicies(ctx, filter, model.Page{
		Number: params.Page,
		Size:   params.Limit,
	})
	if err != nil {
		return nil, err
	}

	var resp []api.ScriptPolicy
	for _, item := range items {
		resp = append(resp, api.ScriptPolicy{
			ID:             item.ID,
			FromScriptHash: model.HashFormat(uint64(item.FromScriptHash)),
			ToScriptID:     item.ToScriptID,
			Policy:         int32(item.Policy),
		})
	}

	return resp, nil
}

// DeleteScriptPolicy implements deleteScriptPolicy operation.
//
// Delete the specified script policy by ID.
//
// DELETE /script-policy/{ScriptPolicyID}
func (svc *Service) DeleteScriptPolicy(ctx context.Context, params api.DeleteScriptPolicyParams) error {
	err := CheckHasRoleScriptWrite(ctx)
	if err != nil {
		return err
	}

	return svc.inner.DeleteScriptPolicy(ctx, params.ScriptPolicyID)
}

// GetScriptPolicy implements getScriptPolicy operation.
//
// Get the specified script policy by ID.
//
// GET /script-policy/{ScriptPolicyID}
func (svc *Service) GetScriptPolicy(ctx context.Context, params api.GetScriptPolicyParams) (*api.ScriptPolicy, error) {
	policy, err := svc.inner.GetScriptPolicy(ctx, params.ScriptPolicyID)
	if err != nil {
		return nil, err
	}

	return &api.ScriptPolicy{
		ID:             policy.ID,
		FromScriptHash: model.HashFormat(uint64(policy.FromScriptHash)),
		ToScriptID:     policy.ToScriptID,
		Policy:         int32(policy.Policy),
	}, nil
}

// UpdateScriptPolicy implements updateScriptPolicy operation.
//
// Update the specified script policy by ID.
//
// POST /script-policy/{ScriptPolicyID}
func (svc *Service) UpdateScriptPolicy(ctx context.Context, req *api.ScriptPolicyUpdate, params api.UpdateScriptPolicyParams) error {
	err := CheckHasRoleScriptWrite(ctx)
	if err != nil {
		return err
	}

	filter := service.NewScriptPolicyFilter()
	if from_script_id, ok := req.FromScriptID.Get(); ok {
		from_script, err := svc.inner.GetScript(ctx, from_script_id)
		if err != nil {
			return err
		}
		filter.SetFromScriptHash(from_script.Hash)
	}
	if to_script_id, to_script_id_ok := req.ToScriptID.Get(); to_script_id_ok{
		filter.SetToScriptID(to_script_id)
	}
	if policy, policy_ok := req.Policy.Get(); policy_ok{
		filter.SetPolicy(policy)
	}

	return svc.inner.UpdateScriptPolicy(ctx, req.ID, filter)
}