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

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

    /// <summary>
    /// NUnit test magic (for skipping the setup)
    /// </summary>
    public const string SKIP_SETUP = "SKIP_SETUP";

    /// <summary>
    /// Reference to the userlist to be tested
    /// </summary>
    private UserList userList;

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

    /// <summary>
    /// Helper variable for quick user creation
    /// </summary>
    private Sprite avatar = Sprite.Create(
        Texture2D.blackTexture,
        new Rect(0, 0, Texture2D.blackTexture.width, Texture2D.blackTexture.height),
        new Vector2(0.5f, 0.5f)
    );

    /// <summary>
    /// Setup the tests
    /// </summary>
    [SetUp]
    public void Setup_UserList()
    {
        // Check whether the current test needs to skip the setup
        ArrayList cat = TestContext.CurrentContext.Test.Properties["_CATEGORIES"] as ArrayList;
        bool skip = cat != null && cat.Contains(SKIP_SETUP);
        if (!skip)
        {
            // The actual setup code
            UserList.PATH = UserListTest.PATH;
            userList = ScriptableObject.CreateInstance<UserList>();
        }
    }

    /// <summary>
    /// Test whether the UserList.PATH is correctly set
    /// </summary>
    [Test]
    [Category(SKIP_SETUP)]
    public void Test_UserList_OnEnable()
    {
        UserList.PATH = null;
        userList = ScriptableObject.CreateInstance<UserList>();
        Assert.AreEqual($"{Application.persistentDataPath}/users.json", UserList.PATH);
    }

    /// <summary>
    /// Test for creation of a new UserList
    /// </summary>
    [Test]
    public void Test_New_UserList()
    {
        Assert.IsNotNull(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_CreateNewUser()
    {
        User user = userList.CreateNewUser(username, avatar);

        Assert.IsNotNull(user);
        Assert.Zero(userList.GetUsers().Count);
        Assert.AreEqual(username, user.username);
        Assert.AreEqual(avatar, user.avatar);
    }

    /// <summary>
    /// Test for creating a new user and adding the user to the list
    /// </summary>
    public void Test_UserList_CreateAndAddNewUser()
    {
        Assert.AreEqual(-1, userList.GetCurrentUserIndex());
        User user = userList.CreateAndAddNewUser(username, avatar);

        Assert.IsNotNull(user);
        Assert.AreEqual(1, userList.GetUsers().Count);
        Assert.AreEqual(user, userList.GetUsers()[0]);
        Assert.Zero(userList.GetCurrentUserIndex());
    }

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

    /// <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 the correct current user is returned
    /// </summary>
    [Test]
    public void Test_UserList_GetCurrentUser()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{username}_{'w'}", avatar);
        userList.ChangeCurrentUser(2);

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

    /// <summary>
    /// Test whether a null user is returned when the userlist is empty
    /// </summary>
    [Test]
    public void Test_UserList_GetCurrent_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_GetCurrentUserIndex()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{username}_{'w'}", avatar);
        userList.ChangeCurrentUser(2);

        int idx = userList.GetCurrentUserIndex();
        Assert.AreEqual(2, idx);
    }

    /// <summary>
    /// Test whether a bad index is returned when the userlist is empty
    /// </summary>
    [Test]
    public void Test_UserList_GetCurrentUserIndex_Empty()
    {
        Assert.AreEqual(-1, userList.GetCurrentUserIndex());
    }

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

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

    /// <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.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{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_ValidUser()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{username}_{'w'}", avatar);
        userList.ChangeCurrentUser(v);
        User V = userList.GetCurrentUser();
        Assert.AreEqual(v, V);
    }

    /// <summary>
    /// Test whether the current user is not changed when a non-existing user is given
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_InvalidUser()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateNewUser($"{username}_{'v'}", avatar);
        Assert.Throws<KeyNotFoundException>(delegate { userList.ChangeCurrentUser(v); });
    }

    /// <summary>
    /// Test whether the current user is not changed when a null user is given
    /// </summary>
    [Test]
    public void Test_UserList_ChangeCurrentUser_NullUser()
    {
        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.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{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.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{username}_{'w'}", avatar);
        Assert.IsFalse(userList.DeleteUser(-1));
        Assert.IsFalse(userList.DeleteUser(5));
    }

    /// <summary>
    /// Test whether deleting any user from an empty userlist will fail
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_IndexEmpty()
    {
        Assert.IsFalse(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_LastValid()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{username}_{'w'}", avatar);
        userList.ChangeCurrentUser(2);

        Assert.AreEqual(3, userList.GetUsers().Count);
        Assert.AreEqual(2, userList.GetCurrentUserIndex());
        Assert.IsTrue(userList.DeleteUser(w));
        Assert.AreEqual(2, userList.GetUsers().Count);
        Assert.AreEqual(1, userList.GetCurrentUserIndex());
    }

    /// <summary>
    /// Test whether deleting an existing user will remove the user correctly
    /// </summary>
    /// <remarks>This will change the currentUserIndex to point to another user</remarks>
    [Test]
    public void Test_UserList_DeleteUser_FirstValid()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateAndAddNewUser($"{username}_{'v'}", avatar);
        User w = userList.CreateAndAddNewUser($"{username}_{'w'}", avatar);
        userList.ChangeCurrentUser(0);

        Assert.AreEqual(3, userList.GetUsers().Count);
        Assert.AreEqual(0, userList.GetCurrentUserIndex());
        Assert.IsTrue(userList.DeleteUser(u));
        Assert.AreEqual(2, userList.GetUsers().Count);
        Assert.AreEqual(0, userList.GetCurrentUserIndex());
    }

    /// <summary>
    /// Test whether deleting a non-existing user will not affect the userlist
    /// </summary>
    [Test]
    public void Test_UserList_DeleteUser_Invalid()
    {
        User u = userList.CreateAndAddNewUser($"{username}_{'u'}", avatar);
        User v = userList.CreateNewUser($"{username}_{'v'}", avatar);

        Assert.AreEqual(1, userList.GetUsers().Count);
        Assert.IsFalse(userList.DeleteUser(v));
        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 = userList.CreateNewUser(username, avatar);
        Assert.Zero(userList.GetUsers().Count);
        Assert.IsFalse(userList.DeleteUser(user));
        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()
    {
        if (File.Exists(PATH))
        {
            File.Delete(PATH);
        }

        List<User> u = new List<User>();
        for (int i = 0; i < 5; i++)
        {
            u.Add(userList.CreateAndAddNewUser($"{username}_{i}", avatar));
        }
        userList.ChangeCurrentUser(3);
        userList.Save();
        FileAssert.Exists(PATH);

        string content = File.ReadAllText(PATH);
        int id = avatar.GetInstanceID();
        string expected = $"{{\"currentUserIndex\":3,\"storedUsers\":[{{\"username\":\"u5erNam3_0\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_1\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_2\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_3\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_4\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}}]}}";
        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.CreateAndAddNewUser($"{username}_{i}", avatar));
        }
        userList.ChangeCurrentUser(3);
        userList.Save();
        FileAssert.Exists(PATH);

        string content = File.ReadAllText(PATH);
        int id = avatar.GetInstanceID();
        string expected = $"{{\"currentUserIndex\":3,\"storedUsers\":[{{\"username\":\"u5erNam3_0\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_1\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_2\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_3\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}},{{\"username\":\"u5erNam3_4\",\"avatar\":{{\"instanceID\":{id}}},\"playtime\":0.0,\"courses\":[],\"minigames\":[]}}]}}";
        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 = "{\"currentUserIndex\":-1,\"storedUsers\":[]}";
        Assert.AreEqual(expected, content);
    }

    /// <summary>
    /// Test whether a userlist (containing some users) is correrctly loaded
    /// </summary>
    [Test]
    public void Test_UserList_Load()
    {
        List<User> u = new List<User>();
        for (int i = 0; i < 5; i++)
        {
            u.Add(userList.CreateAndAddNewUser($"{username}_{i}", avatar));
        }
        userList.ChangeCurrentUser(3);
        userList.Save();

        userList.Load();
        Assert.AreEqual(userList.GetUsers().Count, u.Count);
        Assert.AreEqual(userList.GetCurrentUserIndex(), 3);
        List<User> v = userList.GetUsers();
        for (int i = 0; i < 5; i++)
        {
            Assert.AreEqual(u[i].username, v[i].username);
            Assert.AreEqual(u[i].avatar, v[i].avatar);
        }
    }

    /// <summary>
    /// Test whether an empty userlist is correctly loaded
    /// </summary>
    [Test]
    public void Test_UserList_Load_Empty()
    {
        userList.Save();
        userList.Load();
        Assert.Zero(userList.GetUsers().Count);
        Assert.AreEqual(-1, userList.GetCurrentUserIndex());
    }

    /// <summary>
    /// Test if the user save file is not found, a new one will be created and an empty userlist will be loaded
    /// </summary>
    [Test]
    public void Test_UserList_Load_NotFound()
    {
        List<User> u = new List<User>();
        for (int i = 0; i < 5; i++)
        {
            u.Add(userList.CreateAndAddNewUser($"{username}_{i}", avatar));
        }
        userList.ChangeCurrentUser(3);
        userList.Save();

        File.Delete(PATH);
        userList.Load();
        Assert.Zero(userList.GetUsers().Count);
    }
}