package test

import (
	"amocrm/internal/initialize"
	"amocrm/internal/models"
	"amocrm/internal/models/amo"
	"amocrm/internal/repository"
	"amocrm/internal/tools"
	"context"
	"encoding/json"
	"fmt"
	"github.com/pioz/faker"
	"github.com/stretchr/testify/assert"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"strconv"
	"testing"
	"time"
)

func Test_Repository(t *testing.T) {
	cfgLogger := zap.NewDevelopmentConfig()
	cfgLogger.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
	cfgLogger.EncoderConfig.ConsoleSeparator = "    "

	logger, err := cfgLogger.Build()
	if err != nil {
		panic(err)
	}

	ctx := context.Background()
	mdb, err := initialize.MongoDB(ctx, initialize.Config{
		MongoHost:     "localhost",
		MongoPort:     "27020",
		MongoDatabase: "admin",
		MongoAuth:     "admin",
		MongoPassword: "test",
		MongoUser:     "test",
	})

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

	repo := repository.NewRepository(repository.Deps{
		MdbUser:   mdb.Collection("amoUsers"),
		Tokens:    mdb.Collection("tokens"),
		Pipelines: mdb.Collection("pipelines"),
		Steps:     mdb.Collection("steps"),
		Tags:      mdb.Collection("tags"),
		Fields:    mdb.Collection("fields"),
		UTMs:      mdb.Collection("utms"),
		Logger:    logger,
	})

	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)
}

func createUser(ctx context.Context, repo *repository.Repository) error {
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		err := repo.CreateAccount(ctx, accID)
		if err != nil {
			return err
		}
	}
	return nil
}

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

		if i%2 == 0 {
			role := faker.String()
			role2 := &role
			info.Role = *role2
			uuid := faker.UUID()
			uuid2 := &uuid
			info.ID = *uuid2
		}

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

	return nil
}

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

			err = repo.CheckUsers(ctx, i, info)
			if err != nil {
				return err
			}
		}
	}
	return err
}

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

		resp, err := repo.GettingUserFromCash(ctx, &req)
		if err != nil {
			return err
		}

		assert.Equal(t, i, len(resp.Items))
		fmt.Println(len(resp.Items))
	}
	return nil
}

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

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

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

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

	return nil
}

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

		resp, err := repo.GettingPipelinesFromCash(ctx, &req)
		if err != nil {
			return err
		}

		assert.Equal(t, i, len(resp.Items))
		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

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

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

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

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

	return nil
}

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

		resp, err := repo.GettingStepsFromCash(ctx, &req)
		if err != nil {
			return err
		}

		assert.Equal(t, i, len(resp.Items))
		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

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

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

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

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

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

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

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

	var testCustomersTags2 amo.ResponseGetListTags
	err = json.Unmarshal([]byte(jsonCustomersTags2), &testCustomersTags2)
	if err != nil {
		return err
	}
	id := 666666
	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.LeadsTags,
			Tags:       testLeadsTags.Embedded.Tags,
		})
		if err != nil {
			return err
		}
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CompaniesTags,
			Tags:       testCompaniesTags.Embedded.Tags,
		})
		if err != nil {
			return err
		}
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CustomersTags,
			Tags:       testCustomersTags.Embedded.Tags,
		})
		if err != nil {
			return err
		}
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.ContactsTags,
			Tags:       testContactsTags.Embedded.Tags,
		})
		if err != nil {
			return err
		}
	}

	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.LeadsTags,
			Tags:       testLeadsTags2.Embedded.Tags,
		})
		if err != nil {
			return err
		}
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CompaniesTags,
			Tags:       testCompaniesTags2.Embedded.Tags,
		})
		if err != nil {
			return err
		}
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CustomersTags,
			Tags:       testCustomersTags2.Embedded.Tags,
		})
		if err != nil {
			return err
		}
		err = repo.CheckTags(ctx, repository.CheckTagsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.ContactsTags,
			Tags:       testContactsTags2.Embedded.Tags,
		})
		if err != nil {
			return err
		}
	}

	return nil
}

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

		resp, err := repo.GettingTagsFromCash(ctx, &req)
		if err != nil {
			return err
		}

		assert.Equal(t, i, len(resp.Items))
		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

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

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

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

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

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

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

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

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

	id := 666666
	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.LeadsTags,
			Fields:     testLeadsFields.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CompaniesTags,
			Fields:     testCompaniesFields.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CustomersTags,
			Fields:     testCustomersFields.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.ContactsTags,
			Fields:     testContactsFields.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
	}

	for i := 0; i < 9; i++ {
		accID := strconv.Itoa(i)
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.LeadsTags,
			Fields:     testLeadsFields2.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CompaniesTags,
			Fields:     testCompaniesFields2.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.CustomersTags,
			Fields:     testCustomersFields2.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
		err = repo.CheckFields(ctx, repository.CheckFieldsDeps{
			AccountID:  accID,
			ID:         id,
			EntityType: amo.ContactsTags,
			Fields:     testContactsFields2.Embedded.CustomFields,
		})
		if err != nil {
			return err
		}
	}

	return nil
}

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

		resp, err := repo.GettingFieldsFromCash(ctx, &req)
		if err != nil {
			return err
		}

		assert.Equal(t, i, len(resp.Items))
		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

func webhookCreate(ctx context.Context, repo *repository.Repository) error {
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		err := repo.WebhookCreate(ctx, models.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 *repository.Repository) error {
	for i := 1; i < 10; i++ {
		accID := strconv.Itoa(i)
		err := repo.WebhookUpdate(ctx, models.Token{
			RefreshToken: faker.UUID(),
			AccessToken:  faker.UUID(),
			AccountID:    accID,
			Expiration:   time.Now().Unix() + int64(i),
			CreatedAt:    time.Now().Unix(),
		})
		if err != nil {
			return err
		}
	}
	return nil
}

func checkExpired(ctx context.Context, repo *repository.Repository) ([]models.Token, error) {
	tokens, err := repo.CheckExpired(ctx)
	if err != nil {
		return nil, err
	}

	return tokens, nil
}

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

	return nil
}

func saveUtms(ctx context.Context, repo *repository.Repository) error {
	for i := 1; i < 10; i++ {
		var utms []models.UTM
		quizId := i
		for j := 1; j < 50; j++ {
			utm := models.UTM{
				Name:       strconv.Itoa(i),
				Quizid:     j,
				Accountid:  faker.Int(),
				Amofieldid: j,
				Createdat:  time.Now().Unix(),
				ID:         strconv.Itoa(i),
			}
			utms = append(utms, utm)
		}
		resp, err := repo.SavingUserUtm(ctx, &models.SaveUserListUTMReq{
			Utms: utms,
		}, strconv.Itoa(i), quizId)
		if err != nil {
			return err
		}
		fmt.Println(resp)
	}

	return nil
}

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

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

		assert.Equal(t, i, len(resp.Items))
		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}
	return nil
}

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

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

	var fordetete []string
	for _, r := range resp.Items {
		fordetete = append(fordetete, r.ObjId)
	}
	err = repo.DeletingUserUtm(ctx, &models.ListDeleteUTMIDsReq{
		fordetete,
	}, 5)
	if err != nil {
		return err
	}

	for i := 1; i < 50; i++ {
		req := models.PaginationReq{
			Page: 1,
			Size: i,
		}

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

		assert.Equal(t, 0, len(resp.Items))
		fmt.Println(resp.Items)
		fmt.Println(len(resp.Items))
	}

	return nil
}