package import_cases

import (
	"github.com/dailymotion/allure-go"
	"github.com/ngaut/log"
	"github.com/tidbcloud/qa-PlatformAPIAuto/models"
	imp "github.com/tidbcloud/qa-PlatformAPIAuto/webScene/import"
	"testing"
)

/*
	basic_operation.go contains basic operation for import test cases.

operations:
1. create import
2. cancel import

cluster type:
1. dedicated cluster in aws
2. dedicated cluster in gcp
3. serverless cluster in aws
*/
var precheckData_1 *models.ImportsValidateBody

var targetTableInfo models.DataflowImportTargetTableInfo

type BasicOperationTest struct {
	imp.BaseImportScene
}

func (t *BasicOperationTest) Run() {
	allure.Test(
		t.T,
		allure.Epic("TestImportBasicOperation"),
		allure.Feature("CreateImport and CancelImport"),
		allure.Description("1. create import; 2. cancel import; 3. create import till completed"),
		allure.Action(func() {
			t.CreateClusterStep()
			//t.CreateTargetTableStep(basicOperationTable)

			// If the provider is aws, we should create import credential one time in the test
			if t.Provider == imp.AwsProvider {
				t.CreateImportCredentialStep()
			}
			// Each test should delete import credential
			//defer t.DeleteImportCredentialStep()

			//import schema and data from s3
			// each test should init data
			t.initData("NoTargetTable", "arn")
			t.ImportPreCheckStep()
			t.SetPrecheckData(precheckData_1)
			t.ImportPreCheckStep()
			t.CreateImportTillCompletedStep()

			//import into pre-created tables
			t.initData("TargetTable", "aksk")
			t.TruncateTargetTableStep(basicOperationTable)
			t.GetTargetTable()
			t.ImportPreCheckStep()
			t.SetPrecheckData(precheckData_1)
			t.SearchImportFiles()
			t.ImportPreCheckStep()
			t.CreateImportStep()
			t.CancelImportStep()
			// re-create table
			t.TruncateTargetTableStep(basicOperationTable)
			t.CreateImportTillCompletedStep()
		}),
	)
}

// RunImportTestBasicOperationInDedicatedAws is a test case for
// basic import operations, like create import, cancel import, in dedicated aws.
func RunImportTestBasicOperation(t *testing.T, clusterId, provider string, isServerless bool) {
	test := &BasicOperationTest{}

	test.Init(t, clusterId, provider, isServerless)
	test.Run()
}

// the table used in this test case
var basicOperationTable = imp.Table{
	SchemaName:      "test",
	TableName:       "person",
	SchemaStatement: "CREATE TABLE IF NOT EXISTS `test`.`person` ( `id` int DEFAULT NULL, `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL, `birthday` date DEFAULT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8;",
}

// initData is used to init import data for different providers
// data should be created previously now, maybe generated by code is better later
func (t *BasicOperationTest) initData(model, bucketAccessType string) {
	var importData *models.ClusterIdImportsBody
	var searchImportFile *models.ImportsSearchimportfilesBody
	var precheckData *models.ImportsValidateBody
	targetTable := &models.CommonTable{
		Schema: basicOperationTable.SchemaName,
		Table:  basicOperationTable.TableName,
	}
	targetTableInfo.TargetTable = targetTable
	targetTableInfo.CustomFile = ""
	if t.Provider == imp.AwsProvider {
		var arn, awsAccessKeyId, awsSecretAccessKey string
		if bucketAccessType == "arn" {
			arn = t.ImportArnName()
			awsAccessKeyId = ""
			awsSecretAccessKey = ""
		} else {
			arn = ""
			awsAccessKeyId, awsSecretAccessKey = t.GetAKSKInfo()
		}
		url := "s3://import-scene-test/basic-operation/"
		region := "ap-southeast-1"
		importData = &models.ClusterIdImportsBody{
			SourceUrl:          url,
			DataSourceType:     int64(imp.ImportDataSourceTypeS3),
			Region:             region,
			DataFormat:         int64(imp.ImportDataFormatSql),
			AwsRoleArn:         arn,
			AwsAccessKeyId:     awsAccessKeyId,
			AwsSecretAccessKey: awsSecretAccessKey,
		}
		precheckData = &models.ImportsValidateBody{
			AwsRoleArn:         arn,
			DataFormat:         int64(imp.ImportDataFormatSql),
			DataSourceType:     int64(imp.ImportDataSourceTypeS3),
			Region:             region,
			SourceUrl:          url,
			CheckItems:         []models.DataflowImportValidationItem{models.SOURCE_ACCESS_CHECK_DataflowImportValidationItem},
			AwsAccessKeyId:     awsAccessKeyId,
			AwsSecretAccessKey: awsSecretAccessKey,
		}
		precheckData_1 = &models.ImportsValidateBody{
			AwsRoleArn:         arn,
			DataFormat:         int64(imp.ImportDataFormatSql),
			DataSourceType:     int64(imp.ImportDataSourceTypeS3),
			Region:             region,
			SourceUrl:          url,
			CheckItems:         []models.DataflowImportValidationItem{models.IMPORT_PRECHECK_DataflowImportValidationItem},
			AwsAccessKeyId:     awsAccessKeyId,
			AwsSecretAccessKey: awsSecretAccessKey,
		}
		searchImportFile = &models.ImportsSearchimportfilesBody{
			AwsRoleArn:         arn,
			DataFormat:         int64(imp.ImportDataFormatSql),
			DataSourceType:     int64(imp.ImportDataSourceTypeS3),
			SourceUri:          url,
			AwsAccessKeyId:     awsAccessKeyId,
			AwsSecretAccessKey: awsSecretAccessKey,
		}
		log.Info("precheckData:%v", precheckData)

	} else {
		url := "gs://import-scene-test/basic-operation/"
		importData = &models.ClusterIdImportsBody{
			SourceUrl:      url,
			DataSourceType: int64(imp.ImportDataSourceTypeGcs),
			DataFormat:     int64(imp.ImportDataFormatSql),
		}
		precheckData = &models.ImportsValidateBody{
			DataFormat:     int64(imp.ImportDataFormatSql),
			DataSourceType: int64(imp.ImportDataSourceTypeGcs),
			SourceUrl:      url,
			CheckItems:     []models.DataflowImportValidationItem{models.SOURCE_ACCESS_CHECK_DataflowImportValidationItem},
		}
		precheckData_1 = &models.ImportsValidateBody{
			DataFormat:     int64(imp.ImportDataFormatSql),
			DataSourceType: int64(imp.ImportDataSourceTypeGcs),
			SourceUrl:      url,
			CheckItems:     []models.DataflowImportValidationItem{models.IMPORT_PRECHECK_DataflowImportValidationItem},
		}
		searchImportFile = &models.ImportsSearchimportfilesBody{
			DataFormat:     int64(imp.ImportDataFormatSql),
			DataSourceType: int64(imp.ImportDataSourceTypeGcs),
			SourceUri:      url,
		}
	}
	if model == "TargetTable" {
		importData.TargetTableInfos = []models.DataflowImportTargetTableInfo{targetTableInfo}
		precheckData.TargetTableInfos = []models.DataflowImportTargetTableInfo{targetTableInfo}
		precheckData_1.TargetTableInfos = []models.DataflowImportTargetTableInfo{targetTableInfo}
		searchImportFile.TargetTableInfos = []models.DataflowImportTargetTableInfo{targetTableInfo}
	}
	if t.Provider == imp.GcpProvider {
		t.DeleteCredential()
	}
	t.SetImportData(importData)
	t.SetPrecheckData(precheckData)
	t.SetSearchFileData(searchImportFile)

	// If the provider is gcp, we should create import credential each init new data set
	if t.Provider == imp.GcpProvider {
		t.CreateImportCredentialStep()
	}
}