package service

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"

	"github.com/gochat/gochat/internal/model"
)

// ========== Team Service test utilities ==========

func createTeamTestAccount(t *testing.T, db *gorm.DB) *model.Account {
	t.Helper()
	account := &model.Account{Name: "TeamSvcOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	return account
}

func createTeamTestUser(t *testing.T, db *gorm.DB, name, email string) *model.User {
	t.Helper()
	user := &model.User{Name: name, Email: email, Provider: "email"}
	require.NoError(t, db.Create(user).Error)
	return user
}

// ========== Team Service tests ==========

func TestTeamService_Get(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	team := &model.Team{AccountID: account.ID, Name: "SvcGetTeam", Description: "Desc"}
	require.NoError(t, db.Create(team).Error)

	result, err := svc.Get(context.Background(), team.ID, account.ID)
	require.NoError(t, err)
	assert.Equal(t, "SvcGetTeam", result.Name)
}

func TestTeamService_Get_NotFound(t *testing.T) {
	_, svc := setupTeamService(t)

	result, err := svc.Get(context.Background(), 9999, 9999)
	assert.Error(t, err)
	assert.Nil(t, result)
}

func TestTeamService_List(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	for i := 0; i < 3; i++ {
		require.NoError(t, db.Create(&model.Team{AccountID: account.ID, Name: "TeamSvc" + string(rune('A'+i))}).Error)
	}

	teams, total, err := svc.List(context.Background(), account.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(3), total)
	assert.Len(t, teams, 3)
}

func TestTeamService_Create(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	autoAssign := true
	team, err := svc.Create(context.Background(), account.ID, CreateTeamRequest{
		Name:               "NewSvcTeam",
		Description:        "Service created team",
		AllowAutoAssignment: &autoAssign,
	})
	require.NoError(t, err)
	assert.NotZero(t, team.ID)
	assert.Equal(t, account.ID, team.AccountID)
	assert.Equal(t, "NewSvcTeam", team.Name)
	assert.True(t, team.AllowAutoAssignment)
}

func TestTeamService_Update(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	team := &model.Team{AccountID: account.ID, Name: "SvcBeforeUpdate"}
	require.NoError(t, db.Create(team).Error)

	updated, err := svc.Update(context.Background(), team.ID, account.ID, UpdateTeamRequest{
		Name:        "SvcAfterUpdate",
		Description: "Updated via service",
	})
	require.NoError(t, err)
	assert.Equal(t, "SvcAfterUpdate", updated.Name)
	assert.Equal(t, "Updated via service", updated.Description)
}

func TestTeamService_Delete(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	team := &model.Team{AccountID: account.ID, Name: "SvcDeleteTeam"}
	require.NoError(t, db.Create(team).Error)

	err := svc.Delete(context.Background(), team.ID, account.ID)
	assert.NoError(t, err)

	found, err := svc.Get(context.Background(), team.ID, account.ID)
	assert.Error(t, err)
	assert.Nil(t, found)
}

func TestTeamService_AddMembers(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	team := &model.Team{AccountID: account.ID, Name: "SvcAddMemberTeam"}
	require.NoError(t, db.Create(team).Error)

	user1 := createTeamTestUser(t, db, "SvcAgent1", "svc1@example.com")
	user2 := createTeamTestUser(t, db, "SvcAgent2", "svc2@example.com")

	members, err := svc.AddMembers(context.Background(), team.ID, account.ID, []uint{user1.ID, user2.ID})
	require.NoError(t, err)
	assert.Len(t, members, 2)
}

func TestTeamService_RemoveMember(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	team := &model.Team{AccountID: account.ID, Name: "SvcRmMemberTeam"}
	require.NoError(t, db.Create(team).Error)

	user := createTeamTestUser(t, db, "SvcAgent3", "svc3@example.com")

	_, err := svc.AddMembers(context.Background(), team.ID, account.ID, []uint{user.ID})
	require.NoError(t, err)

	err = svc.RemoveMember(context.Background(), team.ID, user.ID, account.ID)
	assert.NoError(t, err)
}

func TestTeamService_ListMembers(t *testing.T) {
	db, svc := setupTeamService(t)
	account := createTeamTestAccount(t, db)

	team := &model.Team{AccountID: account.ID, Name: "SvcListMembersTeam"}
	require.NoError(t, db.Create(team).Error)

	for i := 0; i < 3; i++ {
		user := createTeamTestUser(t, db, "SvcListAgent"+string(rune('A'+i)), "svclist"+string(rune('A'+i))+"@example.com")
		_, err := svc.AddMembers(context.Background(), team.ID, account.ID, []uint{user.ID})
		require.NoError(t, err)
	}

	members, err := svc.ListMembers(context.Background(), team.ID, account.ID)
	require.NoError(t, err)
	assert.Len(t, members, 3)
}

// ========== Profile Service tests ==========

func TestProfileService_Get(t *testing.T) {
	db, svc := setupProfileService(t)

	user := &model.User{Name: "ProfileUser", Email: "profile@example.com", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	result, err := svc.Get(context.Background(), user.ID)
	require.NoError(t, err)
	assert.Equal(t, "ProfileUser", result.Name)
	assert.Equal(t, "profile@example.com", result.Email)
}

func TestProfileService_Get_NotFound(t *testing.T) {
	_, svc := setupProfileService(t)

	result, err := svc.Get(context.Background(), 9999)
	assert.Error(t, err)
	assert.Nil(t, result)
}

func TestProfileService_Update(t *testing.T) {
	db, svc := setupProfileService(t)

	user := &model.User{Name: "BeforeProfile", Email: "before@example.com", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	updated, err := svc.Update(context.Background(), user.ID, UpdateProfileRequest{
		Name:         "AfterProfile",
		Email:        "after@example.com",
		Availability: "online",
	})
	require.NoError(t, err)
	assert.Equal(t, "AfterProfile", updated.Name)
	assert.Equal(t, "after@example.com", updated.Email)
}

func TestProfileService_UpdateAvatar(t *testing.T) {
	db, svc := setupProfileService(t)

	user := &model.User{Name: "AvatarUser", Email: "avatar@example.com", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	updated, err := svc.UpdateAvatar(context.Background(), user.ID, UpdateAvatarRequest{
		AvatarURL: "https://example.com/avatar.png",
	})
	require.NoError(t, err)
	assert.Equal(t, "https://example.com/avatar.png", updated.AvatarURL)
}