package postgres

import (
	"context"
	"fmt"
	"reflect"
	"testing"
	"time"

	"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
	"git.dragse.it/anthrove/otter-space-sdk/test"
	"gorm.io/gorm"
)

func TestCreateUser(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	invalidUserID := models.AnthroveUserID("XXX")

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "Test 1: Valid AnthroveUserID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
			},
			wantErr: false,
		},
		{
			name: "Test 2: Invalid AnthroveUserID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: invalidUserID,
			},
			wantErr: true,
		},
		{
			name: "Test 3: No anthroveUserID given",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := CreateUser(tt.args.ctx, tt.args.db, tt.args.anthroveUserID); (err != nil) != tt.wantErr {
				t.Errorf("CreateUser() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestCreateUserNodeWithSourceRelation(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	invalidUserID := models.AnthroveUserID("XXX")

	validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))

	source := &models.Source{
		BaseModel: models.BaseModel[models.AnthroveSourceID]{
			ID: validSourceID,
		},
		DisplayName: "e621",
		Domain:      "e621.net",
		Icon:        "icon.e621.net",
	}
	err = CreateSource(ctx, gormDB, source)
	if err != nil {
		t.Fatal(err)
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
		sourceID       models.AnthroveSourceID
		userID         string
		username       string
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "Test 1: Valid anthroveUserID, sourceID, userID, username",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       source.ID,
				userID:         "e1",
				username:       "marius",
			},
			wantErr: false,
		},
		{
			name: "Test 2: Invalid anthroveUserID, valid sourceID, userID, username",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: invalidUserID,
				sourceID:       source.ID,
				userID:         "e1",
				username:       "marius",
			},
			wantErr: true,
		},
		{
			name: "Test 3: Empty anthroveUserID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				sourceID:       source.ID,
				userID:         "e1",
				username:       "marius",
			},
			wantErr: true,
		},
		{
			name: "Test 4: invalid sourceID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "fa.net",
				userID:         "e1",
				username:       "marius",
			},
			wantErr: true,
		},
		{
			name: "Test 5: no userID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       source.ID,
				userID:         "",
				username:       "marius",
			},
			wantErr: true,
		},
		{
			name: "Test 6: no username",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       source.ID,
				userID:         "aa",
				username:       "",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := CreateUserWithRelationToSource(tt.args.ctx, tt.args.db, tt.args.anthroveUserID, tt.args.sourceID, tt.args.userID, tt.args.username); (err != nil) != tt.wantErr {
				t.Errorf("CreateUserWithRelationToSource() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestGetAllUsers(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test
	validUserID01 := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	validUserID02 := models.AnthroveUserID(fmt.Sprintf("%025s", "User2"))
	validUserID03 := models.AnthroveUserID(fmt.Sprintf("%025s", "User3"))

	users := []models.User{
		{
			BaseModel: models.BaseModel[models.AnthroveUserID]{ID: validUserID01},
		},
		{
			BaseModel: models.BaseModel[models.AnthroveUserID]{ID: validUserID02},
		},
		{
			BaseModel: models.BaseModel[models.AnthroveUserID]{ID: validUserID03},
		},
	}

	for _, user := range users {
		err = CreateUser(ctx, gormDB, user.ID)
		if err != nil {
			t.Fatal(err)
		}
	}

	// Test
	type args struct {
		ctx context.Context
		db  *gorm.DB
	}
	tests := []struct {
		name    string
		args    args
		want    []models.User
		wantErr bool
	}{
		{
			name: "Test 1: Get Data",
			args: args{
				ctx: ctx,
				db:  gormDB,
			},
			want:    users,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GetAllUsers(tt.args.ctx, tt.args.db)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetAllUsers() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !checkUser(got, tt.want) {
				t.Errorf("GetAllUsers() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetUserSourceBySourceID(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	invalidUserID := models.AnthroveUserID("XXX")

	validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))

	source := &models.Source{
		BaseModel: models.BaseModel[models.AnthroveSourceID]{
			ID: validSourceID,
		},
		DisplayName: "e621",
		Domain:      "e621.net",
		Icon:        "https://e621.icon",
	}

	expectedResult := &models.UserSource{
		UserID:          string(validUserID),
		AccountUsername: "euser",
		Source: models.Source{
			BaseModel:   models.BaseModel[models.AnthroveSourceID]{ID: source.ID},
			DisplayName: source.DisplayName,
			Domain:      source.Domain,
			Icon:        source.Icon,
		},
	}

	err = CreateSource(ctx, gormDB, source)
	if err != nil {
		t.Fatal(err)
	}

	err = CreateUserWithRelationToSource(ctx, gormDB, validUserID, validSourceID, expectedResult.UserID, expectedResult.AccountUsername)
	if err != nil {
		t.Fatal(err)
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
		sourceID       models.AnthroveSourceID
	}
	tests := []struct {
		name    string
		args    args
		want    *models.UserSource
		wantErr bool
	}{
		{
			name: "Test 1: Valid AnthroveUserID and sourceID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       source.ID,
			},
			want:    expectedResult,
			wantErr: false,
		},
		{
			name: "Test 2: Invalid AnthroveUserID and valid sourceID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: invalidUserID,
				sourceID:       source.ID,
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 3: Valid AnthroveUserID and invalid sourceID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "fa",
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 4: No AnthroveUserID and Valid sourceID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				sourceID:       source.ID,
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 5: Valid AnthroveUserID and No anthroveUserID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "1",
				sourceID:       "",
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 6: No AnthroveUserID and No anthroveUserID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				sourceID:       "",
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 7: No anthroveUserID given",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "",
			},
			want:    nil,
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GetUserSourceBySourceID(tt.args.ctx, tt.args.db, tt.args.anthroveUserID, tt.args.sourceID)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetUserSourceBySourceID() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !checkUserSource(got, tt.want) {
				t.Errorf("GetUserSourceBySourceID() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetUserFavoriteNodeWithPagination(t *testing.T) {
	// Setup trow away containert
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test
	validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))

	validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1"))
	validPostID2 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post2"))
	validPostID3 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post3"))
	validPostID4 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post4"))
	validPostID5 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post5"))
	validPostID6 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post6"))

	expectedResultPosts := []models.Post{
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID1},
			Rating:    "safe",
		},
		{

			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID2},
			Rating:    "safe",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID3},
			Rating:    "explicit",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID4},
			Rating:    "explicit",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID5},
			Rating:    "questionable",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID6},
			Rating:    "safe",
		},
	}
	expectedResult := &models.FavoriteList{
		Posts: expectedResultPosts,
	}
	expectedResult2 := &models.FavoriteList{
		Posts: expectedResultPosts[2:],
	}
	expectedResult3 := &models.FavoriteList{
		Posts: expectedResultPosts[:3],
	}

	err = CreateUser(ctx, gormDB, validAnthroveUserID)
	if err != nil {
		t.Fatal(err)
	}

	for _, expectedResultPost := range expectedResultPosts {
		err = CreatePost(ctx, gormDB, &expectedResultPost)
		if err != nil {
			t.Fatal(err)
		}
		err = CreateReferenceBetweenUserAndPost(ctx, gormDB, validAnthroveUserID, expectedResultPost.ID)
		if err != nil {
			t.Fatal(err)
		}
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
		skip           int
		limit          int
	}
	tests := []struct {
		name    string
		args    args
		want    *models.FavoriteList
		wantErr bool
	}{
		{
			name: "Test 1: Valid AnthroveUserID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validAnthroveUserID,
				skip:           0,
				limit:          2000,
			},
			want:    expectedResult,
			wantErr: false,
		},
		{
			name: "Test 2: Skip first two",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validAnthroveUserID,
				skip:           2,
				limit:          2000,
			},
			want:    expectedResult2,
			wantErr: false,
		},
		{
			name: "Test 3: Limit of 3",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validAnthroveUserID,
				skip:           0,
				limit:          3,
			},
			want:    expectedResult3,
			wantErr: false,
		},
		{
			name: "Test 4: No anthroveUserID given",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				skip:           0,
				limit:          3,
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 5: Short anthroveUserID given",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "aaa",
				skip:           0,
				limit:          3,
			},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GetUserFavoriteWithPagination(tt.args.ctx, tt.args.db, tt.args.anthroveUserID, tt.args.skip, tt.args.limit)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetAllUserFavoritesWithPagination() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetAllUserFavoritesWithPagination() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetUserFavoritesCount(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))

	validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1"))
	validPostID2 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post2"))
	validPostID3 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post3"))
	validPostID4 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post4"))
	validPostID5 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post5"))
	validPostID6 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post6"))

	expectedResultPosts := []models.Post{
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID1},
			Rating:    "safe",
		},
		{

			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID2},
			Rating:    "safe",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID3},
			Rating:    "explicit",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID4},
			Rating:    "explicit",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID5},
			Rating:    "questionable",
		},
		{
			BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID6},
			Rating:    "safe",
		},
	}

	err = CreateUser(ctx, gormDB, validAnthroveUserID)
	if err != nil {
		t.Fatal(err)
	}

	for _, post := range expectedResultPosts {
		err = CreatePost(ctx, gormDB, &post)
		if err != nil {
			t.Fatal(err)
		}
		err = CreateReferenceBetweenUserAndPost(ctx, gormDB, validAnthroveUserID, post.ID)
		if err != nil {
			t.Fatal(err)
		}
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
	}
	tests := []struct {
		name    string
		args    args
		want    int64
		wantErr bool
	}{
		{
			name: "Test 1: Valid anthroveUserID and 6 favorite posts",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validAnthroveUserID,
			},
			want:    6,
			wantErr: false,
		},
		{
			name: "Test 2: Invalid anthroveUserID and 6 favorite posts",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "2",
			},
			want:    0,
			wantErr: true,
		},
		{
			name: "Test 3: no anthroveUserID and 6 favorite posts",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
			},
			want:    0,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GetUserFavoritesCount(tt.args.ctx, tt.args.db, tt.args.anthroveUserID)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetUserFavoritesCount() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("GetUserFavoritesCount() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetUserSourceLinks(t *testing.T) {
	// Setup trow away containert
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test
	validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))

	validSourceID1 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))
	validSourceID2 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source2"))

	eSource := &models.Source{
		BaseModel:   models.BaseModel[models.AnthroveSourceID]{ID: validSourceID1},
		DisplayName: "e621",
		Domain:      "e621.net",
	}
	err = CreateSource(ctx, gormDB, eSource)
	if err != nil {
		t.Fatal("Create Source e621:", err)
	}

	faSource := &models.Source{
		BaseModel:   models.BaseModel[models.AnthroveSourceID]{ID: validSourceID2},
		DisplayName: "fa",
		Domain:      "fa.net",
	}
	err = CreateSource(ctx, gormDB, faSource)
	if err != nil {
		t.Fatal("Create Source fa:", err)
	}

	expectedResult := make(map[string]models.UserSource)
	expectedResult["e621"] = models.UserSource{
		UserID:          "e1",
		AccountUsername: "e621-user",
		Source: models.Source{
			DisplayName: eSource.DisplayName,
			Domain:      eSource.Domain,
		},
	}
	expectedResult["fa"] = models.UserSource{
		UserID:          "fa1",
		AccountUsername: "fa-user",
		Source: models.Source{
			DisplayName: faSource.DisplayName,
			Domain:      faSource.Domain,
		},
	}

	err = CreateUserWithRelationToSource(ctx, gormDB, validAnthroveUserID, eSource.ID, expectedResult["e621"].UserID, expectedResult["e621"].AccountUsername)
	if err != nil {
		t.Fatal("CreateUserWithRelationToSource e621:", err)
	}
	err = CreateUserWithRelationToSource(ctx, gormDB, validAnthroveUserID, faSource.ID, expectedResult["fa"].UserID, expectedResult["fa"].AccountUsername)
	if err != nil {
		t.Fatal("CreateUserWithRelationToSource fa:", err)
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
	}
	tests := []struct {
		name    string
		args    args
		want    map[string]models.UserSource
		wantErr bool
	}{
		{
			name: "Test 1: Get Data",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validAnthroveUserID,
			},
			want:    expectedResult,
			wantErr: false,
		},
		{
			name: "Test 3: No AnthroveID",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 1: AnthroveID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "aaa",
			},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GetUserSourceLinks(tt.args.ctx, tt.args.db, tt.args.anthroveUserID)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetAllUserSources() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetAllUserSources() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetUserTagNodeWitRelationToFavedPosts(t *testing.T) {
	// Setup trow away containert
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test
	validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))

	validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1"))
	validPostID2 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post2"))
	validPostID3 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post3"))

	err = CreateUser(ctx, gormDB, validAnthroveUserID)
	if err != nil {
		t.Fatal(err)
	}

	posts := []models.Post{
		{BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID1}, Rating: "safe"},
		{BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID2}, Rating: "safe"},
		{BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID3}, Rating: "explicit"},
	}

	for _, post := range posts {
		err = CreatePost(ctx, gormDB, &post)
		if err != nil {
			t.Fatal(err)
		}
		err = CreateReferenceBetweenUserAndPost(ctx, gormDB, validAnthroveUserID, post.ID)
		if err != nil {
			t.Fatal(err)
		}
	}

	tags := []models.Tag{
		{Name: "JayTheFerret", Type: "artist"},
		{Name: "Ferret", Type: "species"},
		{Name: "Jay", Type: "character"},
	}

	for i, tag := range tags {
		err = CreateTagAndReferenceToPost(ctx, gormDB, posts[i].ID, &tag)
		if err != nil {
			t.Fatal(err)
		}
	}

	expectedResult := []models.TagsWithFrequency{
		{
			Frequency: 1,
			Tags: models.Tag{
				Name: tags[0].Name,
				Type: tags[0].Type,
			},
		},
		{
			Frequency: 1,
			Tags: models.Tag{
				Name: tags[2].Name,
				Type: tags[2].Type,
			},
		},
		{
			Frequency: 1,
			Tags: models.Tag{
				Name: tags[1].Name,
				Type: tags[1].Type,
			},
		},
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
	}
	tests := []struct {
		name    string
		args    args
		want    []models.TagsWithFrequency
		wantErr bool
	}{
		{
			name: "Test 1: Get Data",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validAnthroveUserID,
			},
			want:    expectedResult,
			wantErr: false,
		},
		{
			name: "Test 2: No anthroveUserID given",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "Test 3: short anthroveUserID given",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "aaa",
			},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GetUserTagWitRelationToFavedPosts(tt.args.ctx, tt.args.db, tt.args.anthroveUserID)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetAllTagsFromUser() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetAllTagsFromUser() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func checkUser(got []models.User, want []models.User) bool {
	for i, user := range want {
		if user.ID != got[i].ID {
			return false
		}
	}
	return true
}

func checkUserSource(got *models.UserSource, want *models.UserSource) bool {

	if got == nil && want == nil {
		return true
	} else if got == nil || want == nil {
		return false
	}

	if got.UserID != want.UserID {
		return false
	}
	if got.AccountUsername != want.AccountUsername {
		return false
	}
	if got.Source.DisplayName != want.Source.DisplayName {
		return false
	}
	if got.Source.Domain != want.Source.Domain {
		return false
	}
	if got.Source.Icon != want.Source.Icon {
		return false
	}

	return true
}

func TestUpdateUserSourceScrapeTimeInterval(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	invalidUserID := models.AnthroveUserID("XXX")

	validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))

	source := &models.Source{
		BaseModel: models.BaseModel[models.AnthroveSourceID]{
			ID: validSourceID,
		},
		DisplayName: "e621",
		Domain:      "e621.net",
		Icon:        "https://e621.icon",
	}

	err = CreateSource(ctx, gormDB, source)
	if err != nil {
		t.Fatal(err)
	}

	err = CreateUserWithRelationToSource(ctx, gormDB, validUserID, validSourceID, "e66e6e6e6", "euser")
	if err != nil {
		t.Fatal(err)
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
		sourceID       models.AnthroveSourceID
		scrapeTime     models.AnthroveScrapeTimeInterval
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "Test 1: Valid Data",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       validSourceID,
				scrapeTime:     10,
			},
			wantErr: false,
		},
		{
			name: "Test 2: anthroveUserID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: invalidUserID,
				sourceID:       validSourceID,
				scrapeTime:     10,
			},
			wantErr: true,
		},
		{
			name: "Test 3: anthroveUserID is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				sourceID:       validSourceID,
				scrapeTime:     10,
			},
			wantErr: true,
		},
		{
			name: "Test 4: anthroveUserID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "111",
				scrapeTime:     10,
			},
			wantErr: true,
		},
		{
			name: "Test 5: anthroveUserID is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "",
				scrapeTime:     10,
			},
			wantErr: true,
		},
		{
			name: "Test 5: scrapeTime is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       validSourceID,
				scrapeTime:     0,
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := UpdateUserSourceScrapeTimeInterval(tt.args.ctx, tt.args.db, tt.args.anthroveUserID, tt.args.sourceID, tt.args.scrapeTime); (err != nil) != tt.wantErr {
				t.Errorf("UpdateUserSourceScrapeTimeInterval() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestUpdateUserSourceLastScrapeTime(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	invalidUserID := models.AnthroveUserID("XXX")

	validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))

	validScrapeTime := models.AnthroveUserLastScrapeTime(time.Now())
	inValidScrapeTime := models.AnthroveUserLastScrapeTime{}

	source := &models.Source{
		BaseModel: models.BaseModel[models.AnthroveSourceID]{
			ID: validSourceID,
		},
		DisplayName: "e621",
		Domain:      "e621.net",
		Icon:        "https://e621.icon",
	}

	err = CreateSource(ctx, gormDB, source)
	if err != nil {
		t.Fatal(err)
	}

	err = CreateUserWithRelationToSource(ctx, gormDB, validUserID, validSourceID, "e66e6e6e6", "euser")
	if err != nil {
		t.Fatal(err)
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
		sourceID       models.AnthroveSourceID
		lastScrapeTime models.AnthroveUserLastScrapeTime
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "Test 1: Valid Data",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       validSourceID,
				lastScrapeTime: validScrapeTime,
			},
			wantErr: false,
		},
		{
			name: "Test 2: anthroveUserID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: invalidUserID,
				sourceID:       validSourceID,
				lastScrapeTime: validScrapeTime,
			},
			wantErr: true,
		},
		{
			name: "Test 3: anthroveUserID is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				sourceID:       validSourceID,
				lastScrapeTime: validScrapeTime,
			},
			wantErr: true,
		},
		{
			name: "Test 4: anthroveUserID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "111",
				lastScrapeTime: validScrapeTime,
			},
			wantErr: true,
		},
		{
			name: "Test 5: anthroveUserID is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "",
				lastScrapeTime: validScrapeTime,
			},
			wantErr: true,
		},
		{
			name: "Test 5: scrapeTime is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       validSourceID,
				lastScrapeTime: inValidScrapeTime,
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := UpdateUserSourceLastScrapeTime(tt.args.ctx, tt.args.db, tt.args.anthroveUserID, tt.args.sourceID, tt.args.lastScrapeTime); (err != nil) != tt.wantErr {
				t.Errorf("UpdateUserSourceLastScrapeTime() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestUpdateUserSourceValidation(t *testing.T) {
	// Setup trow away container
	ctx := context.Background()
	container, gormDB, err := test.StartPostgresContainer(ctx)
	if err != nil {
		t.Fatalf("Could not start PostgreSQL container: %v", err)
	}
	defer container.Terminate(ctx)

	// Setup Test

	validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
	invalidUserID := models.AnthroveUserID("XXX")

	validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))

	source := &models.Source{
		BaseModel: models.BaseModel[models.AnthroveSourceID]{
			ID: validSourceID,
		},
		DisplayName: "e621",
		Domain:      "e621.net",
		Icon:        "https://e621.icon",
	}

	err = CreateSource(ctx, gormDB, source)
	if err != nil {
		t.Fatal(err)
	}

	err = CreateUserWithRelationToSource(ctx, gormDB, validUserID, validSourceID, "e66e6e6e6", "euser")
	if err != nil {
		t.Fatal(err)
	}

	// Test
	type args struct {
		ctx            context.Context
		db             *gorm.DB
		anthroveUserID models.AnthroveUserID
		sourceID       models.AnthroveSourceID
		valid          bool
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "Test 1: Valid Data",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       validSourceID,
				valid:          true,
			},
			wantErr: false,
		},
		{
			name: "Test 2: anthroveUserID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: invalidUserID,
				sourceID:       validSourceID,
				valid:          true,
			},
			wantErr: true,
		},
		{
			name: "Test 3: anthroveUserID is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: "",
				sourceID:       validSourceID,
				valid:          true,
			},
			wantErr: true,
		},
		{
			name: "Test 4: anthroveUserID to short",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "111",
				valid:          true,
			},
			wantErr: true,
		},
		{
			name: "Test 5: anthroveUserID is empty",
			args: args{
				ctx:            ctx,
				db:             gormDB,
				anthroveUserID: validUserID,
				sourceID:       "",
				valid:          true,
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := UpdateUserSourceValidation(tt.args.ctx, tt.args.db, tt.args.anthroveUserID, tt.args.sourceID, tt.args.valid); (err != nil) != tt.wantErr {
				t.Errorf("UpdateUserSourceValidation() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}