using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;

/// <summary>
/// Test the UserList class
/// </summary>
[TestFixture]
public class UserListTests
{
    /// <summary>
    /// Create a new path so the existing .json file will not be overwritten
    /// </summary>
    private static string PATH = $"{Application.persistentDataPath}/wesign_unit_test.json";

    /// <summary>
    /// Helper variable for quick user creation
    /// </summary>
    private string username = "u5erNam3";

    /// <summary>
    /// Helper variable for quick user creation
    /// </summary>
    private Sprite avatar = null;

    /// <summary>
    /// Setup the tests
    /// </summary>
    [SetUp]
    public void Setup_UserList()
    {
        PersistentDataController.PATH = UserListTests.PATH;

        if (File.Exists(PATH))
            File.Delete(PATH);

        PersistentDataController.GetInstance().Load();
        AssetDatabase.LoadAssetAtPath<UserAvatarList>("Assets/Accounts/ScriptableObjects/UserAvatarList.asset").Awake();
        avatar = UserList.AVATARS[0];
    }

    /// <summary>
    /// Cleanup after testing
    /// </summary>
    [TearDown]
    public void TearDown_UserList()
    {
        PersistentDataController.PATH = null;
    }

    /// <summary>
    /// Test for creation of a new UserList
    /// </summary>
    [Test]
    public void Test_New_UserList()
    {
        Assert.Zero(UserList.GetUsers().Count);
    }

    /// <summary>
    /// Test for creation of new user (without adding the user to the list)
    /// </summary>
    [Test]
    public void Test_UserList_AddUser()
    {
        Assert.Zero(UserList.GetUsers().Count);
        User user = UserList.AddUser(username, avatar);

        Assert.IsNotNull(user);
        Assert.AreEqual(1, UserList.GetUsers().Count);
        Assert.AreEqual(username, user.GetUsername());
        Assert.AreEqual(avatar, user.GetAvatar());
    }

    /// <summary>
    /// Test whether an existing user can be found by its username
    /// </summary>
    [Test]
    public void Test_UserList_GetUserByUsername_Valid()
    {
        User u = UserList.AddUser(username, avatar);
        User v = UserList.GetUserByUsername(username);
        Assert.AreEqual(u.GetUsername(), v.GetUsername());
    }

    /// <summary>
    /// Test whether a non-existing user can not be found
    /// </summary>
    [Test]
    public void Test_UserList_GetUserByUsername_Null()
    {
        User user = UserList.GetUserByUsername("not-a-user");
        Assert.IsNull(user);
    }

    /// <summary>
    /// Test whether an existing user can be found by its username
    /// </summary>
    [Test]
    public void Test_UserList_GetUserByIndex_Valid()
    {
        User u = UserList.AddUser(username, avatar);
        User v = UserList.GetUserByIndex(0);
        Assert.AreEqual(u.GetUsername(), v.GetUsername());
    }

    /// <summary>
    /// Test whether a non-existing user can not be found
    /// </summary>
    [Test]
    public void Test_UserList_GetUserByIndex_Exception()
    {
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.GetUserByIndex(0); });
    }

    /// <summary>
    /// Test whether a userlist is correctly returned
    /// </summary>
    [Test]
    public void Test_UserList_GetUsers()
    {
        List<User> u = new List<User>();
        for (int i = 0; i < 5; i++)
            u.Add(UserList.AddUser($"{username}_{i}", avatar));

        List<User> v = UserList.GetUsers();
        Assert.AreEqual(v.Count, u.Count);
        for (int i = 0; i < 5; i++)
            Assert.AreEqual(u[i].GetUsername(), v[i].GetUsername());
    }

    /// <summary>
    /// Test whether the correct current user is returned
    /// </summary>
    [Test]
    public void Test_UserList_GetCurrentUser()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(2);

        User W = UserList.GetCurrentUser();
        Assert.AreEqual(w.GetUsername(), W.GetUsername());
    }

    /// <summary>
    /// Test whether a null user is returned when the userlist is empty
    /// </summary>
    [Test]
    public void Test_UserList_GetCurrentUser_Empty()
    {
        User user = UserList.GetCurrentUser();
        Assert.IsNull(user);
    }

    /// <summary>
    /// Test whether the correct index is returned for the current user
    /// </summary>
    [Test]
    public void Test_UserList_IndexOf_Valid()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(2);

        Assert.AreEqual(0, UserList.IndexOf(u.GetUsername()));
        Assert.AreEqual(1, UserList.IndexOf(v.GetUsername()));
        Assert.AreEqual(2, UserList.IndexOf(w.GetUsername()));
    }

    /// <summary>
    /// Test whether the correct index is returned for the current user
    /// </summary>
    [Test]
    public void Test_UserList_IndexOf_Exception()
    {
        User u = new User(new PersistentDataController.SavedUserData()
        {
            username = username,
            avatarIndex = 0
        });
        Assert.Throws<KeyNotFoundException>(delegate { UserList.IndexOf(u.GetUsername()); });
    }

    /// <summary>
    /// Test whether the current user (referenced by index) is correctly changed
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_ValidIndex()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(2);

        User W = UserList.GetCurrentUser();
        Assert.AreEqual(w.GetUsername(), W.GetUsername());
    }

    /// <summary>
    /// Test whether the current user is not changed when a bad index is given
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_InvalidIndex()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.ChangeCurrentUser(-1); });
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.ChangeCurrentUser(5); });
    }

    /// <summary>
    /// Test whether the current user is not changed when a bad index is given
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_IndexEmpty()
    {
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.ChangeCurrentUser(0); });
    }

    /// <summary>
    /// Test whether the current user is correctly changed
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_ValidUsername()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(v.GetUsername());
        User V = UserList.GetCurrentUser();
        Assert.AreEqual(v.GetUsername(), V.GetUsername());
    }

    /// <summary>
    /// Test whether the current user is not changed when a non-existing user is given
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_InvalidUsername()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = new User(new PersistentDataController.SavedUserData()
        {
            username = $"{username}_{'v'}",
            avatarIndex = 0
        });
        Assert.Throws<KeyNotFoundException>(delegate { UserList.ChangeCurrentUser(v.GetUsername()); });
    }

    /// <summary>
    /// Test whether the current user is not changed when a null user is given
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_NullUsername()
    {
        Assert.Throws<KeyNotFoundException>(delegate { UserList.ChangeCurrentUser(null); });
    }

    /// <summary>
    /// Test whether deleting a existing user (referenced by index) will correctly be removed
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_ValidIndex()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        Assert.IsTrue(UserList.DeleteUser(1));
    }

    /// <summary>
    /// Test whether deleting a non-existing user (referenced by wrong index) will fail
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_InvalidIndex()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.DeleteUser(-1); });
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.DeleteUser(5); });
    }

    /// <summary>
    /// Test whether deleting any user from an empty userlist will fail
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_IndexEmpty()
    {
        Assert.Throws<IndexOutOfRangeException>(delegate { UserList.DeleteUser(0); });
    }

    /// <summary>
    /// Test whether deleting an existing user will correctly remove the user and set the currentUserIndex correctly
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_BeforeCurrentUser()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(1);

        Assert.AreEqual(3, UserList.GetUsers().Count);
        Assert.AreEqual(1, UserList.IndexOf(UserList.GetCurrentUser().GetUsername()));
        Assert.IsTrue(UserList.DeleteUser(u.GetUsername()));
        Assert.AreEqual(2, UserList.GetUsers().Count);
        Assert.AreEqual(0, UserList.IndexOf(UserList.GetCurrentUser().GetUsername()));
    }

    /// <summary>
    /// Test whether deleting an existing user will correctly remove the user and set the currentUserIndex correctly
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_CurrentUser()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(1);

        Assert.AreEqual(3, UserList.GetUsers().Count);
        Assert.AreEqual(1, UserList.IndexOf(UserList.GetCurrentUser().GetUsername()));
        Assert.IsTrue(UserList.DeleteUser(v.GetUsername()));
        Assert.AreEqual(2, UserList.GetUsers().Count);
        Assert.AreEqual(0, UserList.IndexOf(UserList.GetCurrentUser().GetUsername()));
    }

    /// <summary>
    /// Test whether deleting an existing user will correctly remove the user and set the currentUserIndex correctly
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_AfterCurrentUser()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = UserList.AddUser($"{username}_{'v'}", avatar);
        User w = UserList.AddUser($"{username}_{'w'}", avatar);
        UserList.ChangeCurrentUser(1);

        Assert.AreEqual(3, UserList.GetUsers().Count);
        Assert.AreEqual(1, UserList.IndexOf(UserList.GetCurrentUser().GetUsername()));
        Assert.IsTrue(UserList.DeleteUser(w.GetUsername()));
        Assert.AreEqual(2, UserList.GetUsers().Count);
        Assert.AreEqual(1, UserList.IndexOf(UserList.GetCurrentUser().GetUsername()));
    }

    /// <summary>
    /// Test whether deleting a non-existing user will not affect the userlist
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_Invalid()
    {
        User u = UserList.AddUser($"{username}_{'u'}", avatar);
        User v = new User(new PersistentDataController.SavedUserData()
        {
            username = $"{username}_{'v'}",
            avatarIndex = 0
        });

        Assert.AreEqual(1, UserList.GetUsers().Count);
        Assert.Throws<KeyNotFoundException>(delegate { UserList.DeleteUser(v.GetUsername()); });
        Assert.AreEqual(1, UserList.GetUsers().Count);
    }

    /// <summary>
    /// Test whether calling the DeleteUser function on an empty list will not affect the userlist
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_Empty()
    {
        User user = new User(new PersistentDataController.SavedUserData()
        {
            username = username,
            avatarIndex = 0
        });
        Assert.Zero(UserList.GetUsers().Count);
        Assert.Throws<KeyNotFoundException>(delegate { UserList.DeleteUser(user.GetUsername()); });
        Assert.Zero(UserList.GetUsers().Count);
    }

    /// <summary>
    /// Test whether a savefile is correctly constructed when no savefile is present
    /// </summary>
    [Test]
    public void Test_UserList_Save_New()
    {
        List<User> u = new List<User>();
        for (int i = 0; i < 5; i++)
            u.Add(UserList.AddUser($"{username}_{i}", avatar));

        UserList.ChangeCurrentUser(3);
        UserList.Save();
        FileAssert.Exists(PATH);

        string content = File.ReadAllText(PATH);
        string expected = $"{{\"version\":{PersistentDataController.VERSION},\"users\":[{{\"entries\":[],\"username\":\"u5erNam3_0\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_1\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_2\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_3\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_4\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}}],\"currentUser\":3,\"currentMinigame\":0,\"currentCourse\":0,\"currentTheme\":0,\"useGPU\":false}}";
        Assert.AreEqual(expected, content);
    }

    /// <summary>
    /// Test whether a savefile is correctly constructed when a savefile already exists
    /// </summary>
    [Test]
    public void Test_UserList_Save_Existing()
    {
        if (!File.Exists(PATH))
        {
            File.CreateText(PATH).Close();
            File.WriteAllText(PATH, "https://www.youtube.com/watch?v=dQw4w9WgXcQ");
        }

        List<User> u = new List<User>();
        for (int i = 0; i < 5; i++)
            u.Add(UserList.AddUser($"{username}_{i}", avatar));

        UserList.ChangeCurrentUser(3);
        UserList.Save();
        FileAssert.Exists(PATH);

        string content = File.ReadAllText(PATH);
        string expected = $"{{\"version\":{PersistentDataController.VERSION},\"users\":[{{\"entries\":[],\"username\":\"u5erNam3_0\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_1\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_2\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_3\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}},{{\"entries\":[],\"username\":\"u5erNam3_4\",\"avatarIndex\":0,\"playtime\":0.0,\"minigames\":[],\"courses\":[]}}],\"currentUser\":3,\"currentMinigame\":0,\"currentCourse\":0,\"currentTheme\":0,\"useGPU\":false}}";
        Assert.AreEqual(expected, content);
    }

    /// <summary>
    /// Test whether a save file is correctly constructed from an empty userlist
    /// </summary>
    [Test]
    public void Test_UserList_Save_Empty()
    {
        UserList.Save();
        FileAssert.Exists(PATH);

        string content = File.ReadAllText(PATH);
        string expected = $"{{\"version\":{PersistentDataController.VERSION},\"users\":[],\"currentUser\":-1,\"currentMinigame\":0,\"currentCourse\":0,\"currentTheme\":0,\"useGPU\":false}}";
        Assert.AreEqual(expected, content);
    }
}