package test

import (
	"amocrm/internal/models"
	"amocrm/internal/tools"
	"context"
	"encoding/json"
	"fmt"
	"github.com/pioz/faker"
	"github.com/stretchr/testify/assert"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
	"strconv"
	"testing"
	"time"
)

func Test_Repository(t *testing.T) {
	ctx := context.Background()
	repo, err := dal.NewAmoDal(ctx, "host=localhost port=35432 user=squiz password=Redalert2 dbname=squiz sslmode=disable")

	if err != nil {
		fmt.Println("err init postgres")
		panic(err)
	}

	err = webhookCreate(ctx, repo)
	assert.NoError(t, err)
	err = webhookUpdate(ctx, repo)
	assert.NoError(t, err)

	count := 0
	for {
		if count == 8 {
			break
		}
		time.Sleep(time.Second)
		tokens, err := checkExpired(ctx, repo)
		assert.NoError(t, err)
		if len(tokens) > 0 {
			fmt.Println(tokens)
			count++
		}
	}

	err = getAllTokens(ctx, t, repo)
	assert.NoError(t, err)
	err = createUser(ctx, repo)
	assert.NoError(t, err)
	err = updateUser(ctx, repo)
	assert.NoError(t, err)
	err = checkUsers(ctx, repo)
	assert.NoError(t, err)
	err = gettingUserFromCash(ctx, t, repo)
	assert.NoError(t, err)
	err = checkPipelines(ctx, repo)
	assert.NoError(t, err)
	err = gettingPipelinesFromCash(ctx, t, repo)
	assert.NoError(t, err)
	err = checkSteps(ctx, repo)
	assert.NoError(t, err)
	err = gettingStepsFromCash(ctx, t, repo)
	assert.NoError(t, err)
	err = checkTags(ctx, repo)
	assert.NoError(t, err)
	err = gettingTagsFromCash(ctx, t, repo)
	assert.NoError(t, err)
	err = checkFields(ctx, repo)
	assert.NoError(t, err)
	err = gettingFieldsFromCash(ctx, t, repo)
	assert.NoError(t, err)
	err = saveUtms(ctx, repo)
	assert.NoError(t, err)
	err = gettingUserUtm(ctx, t, repo)
	assert.NoError(t, err)
	err = deleteUserUTM(ctx, t, repo)
	assert.NoError(t, err)
	RuleTest(ctx, repo)
}

func createUser(ctx context.Context, repo *dal.AmoDal) error {
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		err := repo.AmoRepo.CreateAccount(ctx, accID, model.User{
			AmoID:     int32(i),
			Name:      "Test" + strconv.Itoa(i),
			Email:     "Test" + strconv.Itoa(i) + "@mail.test",
			Amouserid: int32(i),
			Subdomain: "Test",
			Country:   "RUSSIA",
		})
		if err != nil {
			return err
		}
	}
	return nil
}

func updateUser(ctx context.Context, repo *dal.AmoDal) error {
	var testUserInfo models.AmocrmUserInformation
	err := json.Unmarshal([]byte(jsonUserInfo), &testUserInfo)
	if err != nil {
		return err
	}
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		info := model.User{
			Name:      faker.String(),
			Subdomain: "pena",
			AmoID:     666,
			Amouserid: int32(i),
			Email:     faker.Email(),
			Group:     int32(i),
			Country:   "Russia",
		}

		if i%2 == 0 {
			info.Role = int32(i)
			info.ID = faker.Int64()
		}

		err = repo.AmoRepo.CreateAccount(ctx, accID, info)
		if err != nil {
			return err
		}
	}

	return nil
}

func checkUsers(ctx context.Context, repo *dal.AmoDal) error {
	var testUserInfo models.AmocrmUserInformation
	err := json.Unmarshal([]byte(jsonUserInfo), &testUserInfo)
	if err != nil {
		return err
	}
	for i := 1; i < 10; i++ {
		if i%2 != 0 {
			info := model.User{
				Name:  faker.String(),
				Email: faker.Email(),
				Group: int32(i),
			}
			info.Role = int32(i)

			err = repo.AmoRepo.CheckAndUpdateUsers(ctx, info)
			if err != nil {
				return err
			}
		}
	}
	return err
}

func gettingUserFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	for i := 1; i < 10; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GettingUserWithPagination(ctx, &req, "5")
		if err != nil {
			return err
		}

		fmt.Println(len(resp.Items))
	}
	return nil
}

func checkPipelines(ctx context.Context, repo *dal.AmoDal) error {
	var testPipeline1 models.PipelineResponse
	err := json.Unmarshal([]byte(jsonPipelines), &testPipeline1)
	if err != nil {
		return err
	}

	var testPipeline2 models.PipelineResponse
	err = json.Unmarshal([]byte(jsonPipelines2), &testPipeline2)
	if err != nil {
		return err
	}

	for i := 0; i < 9; i++ {
		err = repo.AmoRepo.CheckPipelines(ctx, tools.ToPipeline(testPipeline1.Embedded.Pipelines))
		if err != nil {
			return err
		}
	}

	for i := 0; i < 9; i++ {
		err = repo.AmoRepo.CheckPipelines(ctx, tools.ToPipeline(testPipeline2.Embedded.Pipelines))
		if err != nil {
			return err
		}
	}

	return nil
}

func gettingPipelinesFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	for i := 1; i < 28; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GetPipelinesWithPagination(ctx, &req, "4")
		if err != nil {
			return err
		}

		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

func checkSteps(ctx context.Context, repo *dal.AmoDal) error {
	var testStep1 models.ResponseGetListSteps
	err := json.Unmarshal([]byte(jsonStep1), &testStep1)
	if err != nil {
		return err
	}

	var testStep2 models.ResponseGetListSteps
	err = json.Unmarshal([]byte(jsonStep2), &testStep2)
	if err != nil {
		return err
	}

	for i := 0; i < 9; i++ {
		err = repo.AmoRepo.CheckSteps(ctx, tools.ToStep(testStep1.Embedded.Statuses))
		if err != nil {
			return err
		}
	}

	for i := 0; i < 9; i++ {
		err = repo.AmoRepo.CheckSteps(ctx, tools.ToStep(testStep2.Embedded.Statuses))
		if err != nil {
			return err
		}
	}

	return nil
}

func gettingStepsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	for i := 1; i < 46; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GetStepsWithPagination(ctx, &req, "3")
		if err != nil {
			return err
		}

		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

func checkTags(ctx context.Context, repo *dal.AmoDal) error {
	var testLeadsTags models.ResponseGetListTags
	err := json.Unmarshal([]byte(jsonLeadsTags), &testLeadsTags)
	if err != nil {
		return err
	}

	var testLeadsTags2 models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonLeadsTags2), &testLeadsTags2)
	if err != nil {
		return err
	}

	var testContactsTags models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonContactsTags), &testContactsTags)
	if err != nil {
		return err
	}

	var testContactsTags2 models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonContactsTags2), &testContactsTags2)
	if err != nil {
		return err
	}

	var testCompaniesTags models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonCompaniesTags), &testCompaniesTags)
	if err != nil {
		return err
	}

	var testCompaniesTags2 models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonCompaniesTags2), &testCompaniesTags2)
	if err != nil {
		return err
	}

	var testCustomersTags models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonCustomersTags), &testCustomersTags)
	if err != nil {
		return err
	}

	var testCustomersTags2 models.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonCustomersTags2), &testCustomersTags2)
	if err != nil {
		return err
	}
	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testLeadsTags.Embedded.Tags, model.LeadsTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCompaniesTags.Embedded.Tags, model.CompaniesTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCustomersTags.Embedded.Tags, model.CustomersTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testContactsTags.Embedded.Tags, model.ContactsTags), accID)
		if err != nil {
			fmt.Println(err)
		}
	}

	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testLeadsTags2.Embedded.Tags, model.LeadsTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCompaniesTags2.Embedded.Tags, model.CompaniesTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCustomersTags2.Embedded.Tags, model.CustomersTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testContactsTags2.Embedded.Tags, model.ContactsTags), accID)
		if err != nil {
			fmt.Println(err)
		}
		if err != nil {
			fmt.Println(err)
		}
	}

	return nil
}

func gettingTagsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	for i := 1; i < 73; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GetTagsWithPagination(ctx, &req, "2")
		if err != nil {
			return err
		}

		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

func checkFields(ctx context.Context, repo *dal.AmoDal) error {
	var testLeadsFields models.ResponseGetListFields
	err := json.Unmarshal([]byte(jsonLeadsFields), &testLeadsFields)
	if err != nil {
		return err
	}

	var testLeadsFields2 models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonLeadsFields2), &testLeadsFields2)
	if err != nil {
		return err
	}

	var testContactsFields models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonContactsFields), &testContactsFields)
	if err != nil {
		return err
	}

	var testContactsFields2 models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonContactsFields2), &testContactsFields2)
	if err != nil {
		return err
	}

	var testCompaniesFields models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonCompaniesFields), &testCompaniesFields)
	if err != nil {
		return err
	}

	var testCompaniesFields2 models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonCompaniesFields2), &testCompaniesFields2)
	if err != nil {
		return err
	}

	var testCustomersFields models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonCustomersFields), &testCustomersFields)
	if err != nil {
		return err
	}

	var testCustomersFields2 models.ResponseGetListFields
	err = json.Unmarshal([]byte(jsonCustomersFields2), &testCustomersFields2)
	if err != nil {
		return err
	}

	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testLeadsFields.Embedded.CustomFields, model.LeadsTags), accID)
		if err != nil {
			return err
		}
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCompaniesFields.Embedded.CustomFields, model.CompaniesTags), accID)
		if err != nil {
			return err
		}
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCustomersFields.Embedded.CustomFields, model.CustomersTags), accID)
		if err != nil {
			return err
		}
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testContactsFields.Embedded.CustomFields, model.ContactsTags), accID)
		if err != nil {
			return err
		}
	}

	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testLeadsFields2.Embedded.CustomFields, model.LeadsTags), accID)
		if err != nil {
			return err
		}
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCompaniesFields2.Embedded.CustomFields, model.CompaniesTags), accID)
		if err != nil {
			return err
		}
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCustomersFields2.Embedded.CustomFields, model.CustomersTags), accID)
		if err != nil {
			return err
		}
		err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testContactsFields2.Embedded.CustomFields, model.ContactsTags), accID)
		if err != nil {
			return err
		}
		if err != nil {
			return err
		}
	}

	return nil
}

func gettingFieldsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	for i := 1; i < 73; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GetFieldsWithPagination(ctx, &req, "1")
		if err != nil {
			return err
		}

		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

func webhookCreate(ctx context.Context, repo *dal.AmoDal) error {
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		err := repo.AmoRepo.WebhookCreate(ctx, model.Token{
			RefreshToken: faker.UUID(),
			AccessToken:  faker.UUID(),
			AccountID:    accID,
			AuthCode:     faker.String(),
			Expiration:   time.Now().Unix() + 10,
			CreatedAt:    time.Now().Unix(),
		})
		if err != nil {
			return err
		}
	}
	return nil
}

func webhookUpdate(ctx context.Context, repo *dal.AmoDal) error {
	var tokens []model.Token
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		tokens = append(tokens, model.Token{
			RefreshToken: faker.UUID(),
			AccessToken:  faker.UUID(),
			AccountID:    accID,
			Expiration:   time.Now().Unix() + int64(i),
			CreatedAt:    time.Now().Unix(),
		})
	}

	err := repo.AmoRepo.WebhookUpdate(ctx, tokens)
	if err != nil {
		fmt.Println(err)
		return err
	}
	return nil
}

func checkExpired(ctx context.Context, repo *dal.AmoDal) ([]model.Token, error) {
	tokens, err := repo.AmoRepo.CheckExpired(ctx)
	if err != nil {
		return nil, err
	}

	return tokens, nil
}

func getAllTokens(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	tokens, err := repo.AmoRepo.GetAllTokens(ctx)
	if err != nil {
		return err
	}
	assert.Equal(t, len(tokens), 9)

	return nil
}

func saveUtms(ctx context.Context, repo *dal.AmoDal) error {
	for i := 1; i < 10; i++ {
		var utms []model.UTM
		for j := 1; j < 50; j++ {
			utm := model.UTM{
				Name:       strconv.Itoa(i),
				Quizid:     int32(j),
				Accountid:  faker.Int32(),
				Amofieldid: int32(j),
				Createdat:  time.Now().Unix(),
			}
			utms = append(utms, utm)
		}
		resp, err := repo.AmoRepo.SavingUserUtm(ctx, utms, strconv.Itoa(i))
		if err != nil {
			return err
		}
		fmt.Println(resp)
	}

	return nil
}

func gettingUserUtm(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	for i := 1; i < 50; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "1", 1)
		if err != nil {
			return err
		}

		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

func deleteUserUTM(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
	req := model.PaginationReq{
		Page: 1,
		Size: 50,
	}

	resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "5", 5)
	if err != nil {
		return err
	}

	var fordetete []int32
	for _, r := range resp.Items {
		fordetete = append(fordetete, int32(r.ID))
	}
	err = repo.AmoRepo.DeletingUserUtm(ctx, &model.ListDeleteUTMIDsReq{
		fordetete,
	})
	if err != nil {
		return err
	}

	for i := 1; i < 50; i++ {
		req := model.PaginationReq{
			Page: 1,
			Size: int32(i),
		}

		resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "5", 5)
		if err != nil {
			return err
		}

		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}

	return nil
}

func RuleTest(ctx context.Context, repo *dal.AmoDal) {
	testMap := make(map[int]int)
	testMap[11111] = 11111
	rule, err := repo.AmoRepo.SetQuizSettings(ctx, &model.RulesReq{
		PerformerID: 2,
		PipelineID:  1,
		StepID:      1,
		Utms:        make([]int32, 3),
		Fieldsrule: model.Fieldsrule{
			Lead: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
			Contact: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
			Company: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
			Customer: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
		},
	}, "3", 3)

	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(rule)

	testMap[222] = 3

	rule2, err := repo.AmoRepo.ChangeQuizSettings(ctx, &model.RulesReq{
		PerformerID: 111,
		PipelineID:  111,
		StepID:      111,
		Utms:        make([]int32, 10),
		Fieldsrule: model.Fieldsrule{
			Lead: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
			Contact: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
			Company: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
			Customer: []model.FieldRule{
				{
					Questionid: testMap,
				},
			},
		},
	}, "3", 3)

	if err != nil {
		fmt.Println(err, "UPDATE")
	}
	fmt.Println(rule2)

	rule3, err := repo.AmoRepo.GettingQuizRules(ctx, 1)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(rule3)
}