using System;
using System.Collections;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;
using Assert = UnityEngine.Assertions.Assert;

namespace BracerLib.Tests.Objects
{
    public class ObjectLifetimeTests : TestBase
    {
        private class SomeDisposable : IDisposable
        {
            public bool IsDisposed { get; private set; }

            public void Dispose()
            {
                if (IsDisposed)
                    return;

                IsDisposed = true;

                GC.SuppressFinalize(this);
            }
        }

        private SomeDisposable disposableObject;
        private SomeDisposable disposableFuncObject;
        private GameObject singleTestLifetimeObject;
        private GameObject singleTestLifetimeFuncObject;
        private GameObject completeTestLifetimeObject;
        private GameObject completeTestLifetimeFuncObject;
        private bool singleTestWasCreated;

        [UnityTest, Order(1)]
        public IEnumerator SetUpOneTimeObjects()
        {
            completeTestLifetimeObject = new GameObject("full lifetime");
            RegisterOneTimeTestObject(completeTestLifetimeObject);

            yield return null;
            Assert.IsTrue(completeTestLifetimeObject != null);

            completeTestLifetimeFuncObject = RegisterOneTimeTestObject(GetNewObject);

            yield return null;
            Assert.IsTrue(completeTestLifetimeFuncObject != null);
        }

        /// <summary>
        /// Not here to test Unity code, but want to run through a basic shift of the object position.
        /// </summary>
        [UnityTest, Order(2)]
        public IEnumerator TempUnityObjectMovesCorrectly()
        {
            Assert.IsFalse(singleTestWasCreated);

            singleTestLifetimeObject = new GameObject("singleTestLifetime");
            RegisterTempTestObject(singleTestLifetimeObject);
            singleTestLifetimeFuncObject = RegisterTempTestObject(GetNewObject);
            singleTestWasCreated = true;

            Assert.IsTrue(singleTestWasCreated);

            yield return null;

            var testTransform = singleTestLifetimeObject.transform;
            var tPos = testTransform.position;
            var lastPos = tPos;
            tPos = Vector3.one;
            testTransform.position = tPos;

            Assert.IsTrue(tPos != lastPos);

            testTransform.Translate(Vector3.up);

            yield return null;

            tPos = testTransform.position;

            Assert.IsTrue(tPos != lastPos);
        }

        [UnityTest, Order(3)]
        public IEnumerator TempUnityObjectNoLongerExistsAfterPreviousTest()
        {
            Assert.IsTrue(singleTestWasCreated);
            Assert.IsNull(singleTestLifetimeObject);
            Assert.IsNull(singleTestLifetimeFuncObject);
            yield return null;
        }

        [UnityTest, Order(4)]
        public IEnumerator OneTimeObjectStillExists()
        {
            Assert.IsTrue(completeTestLifetimeObject != null);
            Assert.IsTrue(completeTestLifetimeFuncObject != null);
            yield return null;
        }

        [Test, Order(5)]
        public void RegisterDisposableObject()
        {
            disposableObject = new SomeDisposable();
            RegisterDisposableTempTestObject(disposableObject);
            Assert.IsNotNull(disposableObject);
            Assert.IsFalse(disposableObject.IsDisposed);

            disposableFuncObject = RegisterDisposableTempTestObject(() => new SomeDisposable());
            Assert.IsNotNull(disposableFuncObject);
            Assert.IsFalse(disposableFuncObject.IsDisposed);
        }

        [Test, Order(6)]
        public void CheckIfDisposableObjectHasDisposed()
        {
            Assert.IsNotNull(disposableObject);
            Assert.IsTrue(disposableObject.IsDisposed);

            disposableObject = null;

            Assert.IsNotNull(disposableFuncObject);
            Assert.IsTrue(disposableFuncObject.IsDisposed);

            disposableObject = null;
        }

        private GameObject GetNewObject() => new GameObject();
    }
}