package common

import (
	"errors"
)

type ClusterIdParameter struct {
	ClusterId uint64 `json:"cluster_id"`
}

func GetClusterId(params any) (uint64, error) {
	clusterParam, ok := params.(*ClusterIdParameter)
	if !ok {
		return 0, errors.New("invalid cluster id parameter type")
	}
	clusterId := clusterParam.ClusterId
	if clusterId == 0 {
		return 0, errors.New("cluster id is empty")
	}
	return clusterId, nil
}

type TidbGroupParameter struct {
	ClusterId   uint64 `json:"cluster_id"`
	TidbGroupId uint64 `json:"tidb_group_id"`
}

func GetTidbGroupIdFromTidbGroupParams(params any) (uint64, error) {
	tidbGroupParam, ok := params.(*TidbGroupParameter)
	if !ok {
		return 0, errors.New("invalid tidb group parameter type")
	}
	tidbGroupId := tidbGroupParam.TidbGroupId
	if tidbGroupId == 0 {
		return 0, errors.New("tidb group id is empty")
	}
	return tidbGroupId, nil
}

func GetClusterIdFromTidbGroupParams(params any) (uint64, error) {
	tidbGroupParam, ok := params.(*TidbGroupParameter)
	if !ok {
		return 0, errors.New("invalid tidb group parameter type")
	}
	clusterId := tidbGroupParam.ClusterId
	if clusterId == 0 {
		return 0, errors.New("cluster id is empty")
	}
	return clusterId, nil
}

type ResourcePoolParameter struct {
	ResourcePoolId uint64 `json:"resource_pool_id"`
}

func GetResourcePoolId(params any) (uint64, error) {
	resourcePoolParam, ok := params.(*ResourcePoolParameter)
	if !ok {
		return 0, errors.New("invalid resource pool parameter type")
	}
	resourcePoolId := resourcePoolParam.ResourcePoolId
	if resourcePoolId == 0 {
		return 0, errors.New("resource pool id is empty")
	}
	return resourcePoolId, nil
}

type PauseResumeResourcePoolParameter struct {
	ResourcePoolId uint64 `json:"resource_pool_id"`
	OperationId    string `json:"operation_id"`
}

func GetPauseResumeResourcePoolParams(params any) (uint64, string, error) {
	pauseResumeParam, ok := params.(*PauseResumeResourcePoolParameter)
	if !ok {
		return 0, "", errors.New("invalid pause/resume resource pool parameter type")
	}
	if pauseResumeParam.ResourcePoolId == 0 {
		return 0, pauseResumeParam.OperationId, errors.New("resource pool id is empty")
	}
	if pauseResumeParam.OperationId == "" {
		return pauseResumeParam.ResourcePoolId, "", errors.New("operation id is empty")
	}
	return pauseResumeParam.ResourcePoolId, pauseResumeParam.OperationId, nil
}

type EncryptionKeyParameter struct {
	EncryptionKeyId uint64 `json:"encryption_key_id"`
}

func GetEncryptionKeyId(params any) (uint64, error) {
	encryptionKeyParam, ok := params.(*EncryptionKeyParameter)
	if !ok {
		return 0, errors.New("invalid encryption key parameter type")
	}
	encryptionKeyId := encryptionKeyParam.EncryptionKeyId
	if encryptionKeyId == 0 {
		return 0, errors.New("encryption key id is empty")
	}
	return encryptionKeyId, nil
}

// ExportParameter is the parameter for export workflow action.
type ExportParameter struct {
	ClusterId   string `json:"cluster_id"`
	ExportId    string `json:"export_id"`
	TidbGroupId string `json:"tidb_group_id,omitempty"`
}

// GetExportParams returns cluster_id and export_id from export action params.
func GetExportParams(params any) (clusterId, exportId string, err error) {
	p, ok := params.(*ExportParameter)
	if !ok {
		return "", "", errors.New("invalid export parameter type")
	}
	if p.ClusterId == "" || p.ExportId == "" {
		return "", "", errors.New("cluster_id and export_id are required")
	}
	return p.ClusterId, p.ExportId, nil
}

func GetTidbGroupIdFromExportParams(params any) (string, error) {
	p, ok := params.(*ExportParameter)
	if !ok {
		return "", errors.New("invalid export parameter type")
	}
	if p.TidbGroupId == "" {
		return "", errors.New("tidb_group_id is required")
	}
	return p.TidbGroupId, nil
}