using DTS.Common.Classes.Groups;
using DTS.Common.Interface.DataRecorders;
using DTS.Common.Interface.Groups;
using NUnit.Framework;
using System;
using System.Linq;

namespace DatabaseUnitTesting
{
    [TestFixture]
    public partial class DBAPITests
    {

        [Test]
        public void TestTestSetupGroupPositive()
        {
            if (!_setup) { Setup(); }
            TestLogin();
            var con = DbAPI.DbAPI.Connections.GetActiveConnections()[0];

            var test = CreateFakeTestSetup();
            _ = DbAPI.DbAPI.TestSetups.TestSetupsUpdateInsert(_user, con, 0, ref test);
            var group = CreateFakeGroup("TestGroup", null);
            _ = DbAPI.DbAPI.Groups.GroupsInsert(_user, con, ref group);

            var insertGroupRecord = new TestSetupGroupRecord()
            {
                DisplayOrder = 0,
                GroupId = group.Id,
                Position = "?",
                TestObjectType = "X",
                TestSetupId = test.Id
            };

            var hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsInsert(_user, con, insertGroupRecord);
            Assert.IsTrue(0 == hr, "TestSetupGroupsInsert returns 0");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, null, null, null, out var groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(g, insertGroupRecord)),
                "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, group.Id, null, null, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, null, test.Id, null, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, null, null, test.Name, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, group.Id, test.Id, null, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, group.Id, null, test.Name, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, null, test.Id, test.Name, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, group.Id, test.Id, test.Name, out groups);
            Assert.IsTrue(0 == hr && null != groups && groups.Any(g => TestSetupGroupRecordEqual(insertGroupRecord, g))
                && 1 == groups.Length, "TestSetupGroupsGet returns inserted group");

            var updateGroupRecord = new TestSetupGroupRecord(insertGroupRecord);
            updateGroupRecord.Position = "Y";
            updateGroupRecord.TestObjectType = "Z";

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsUpdate(_user, con, updateGroupRecord);
            Assert.IsTrue(0 == hr, "TestSetupGroupsUpdate returns 0");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, null, test.Id, null, out groups);
            Assert.IsTrue(0 == hr && 1 == groups.Length && TestSetupGroupRecordEqual(groups[0], updateGroupRecord),
                "TestSetupGroupsGet returns updated group");

            hr = DbAPI.DbAPI.Groups.GroupsDelete(_user, con, group.Id, out var error);
            Assert.IsTrue(0 == hr, "Groups can delete a group");

            hr = DbAPI.DbAPI.TestSetups.TestSetupsDeleteById(_user, con, new[] { test.Id });
            Assert.IsTrue(0 == hr, "Test setup can be deleted");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, con, null, null, null, out groups);
            Assert.IsTrue(0 == hr && null == groups || 0 == groups.Length || !groups.Any(g => TestSetupGroupRecordEqual(g, updateGroupRecord)),
                "TestSetupsDelete removed any group record");
        }

        private bool TestSetupGroupRecordEqual(ITestSetupGroupRecord left, ITestSetupGroupRecord right)
        {
            return left.DisplayOrder == right.DisplayOrder
                && left.GroupId == right.GroupId
                && left.Position == right.Position
                && left.TestObjectType == right.TestObjectType
                && left.TestSetupId == right.TestSetupId;
        }
        [Test]
        public void TestTestSetupGroupNegative()
        {
            if (!_setup) { Setup(); }
            TestLogin();
            var con = DbAPI.DbAPI.Connections.GetActiveConnections()[0];
            var hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(_user, null, null, null, null, out var groups);
            Assert.IsTrue(0 != hr && (null == groups || 0 == groups.Length), "TestSetups should not work without a connection");
            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsGet(null, con, null, null, null, out groups);
            Assert.IsTrue(0 != hr && (null == groups || 0 == groups.Length), "TestSetups should not work without a user");

            var test = CreateFakeTestSetup();
            _ = DbAPI.DbAPI.TestSetups.TestSetupsUpdateInsert(_user, con, 0, ref test);
            var group = CreateFakeGroup("FakeGroup", null);
            _ = DbAPI.DbAPI.Groups.GroupsInsert(_user, con, ref group);

            var groupToInsert = new TestSetupGroupRecord() { DisplayOrder = 0, GroupId = group.Id, Position = "?", TestObjectType = "?", TestSetupId = test.Id };

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsInsert(null, con, groupToInsert);
            Assert.IsTrue(0 != hr, "TestSetupsGroupsInsert should not work without user");
            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsInsert(_user, null, groupToInsert);
            Assert.IsTrue(0 != hr, "TestSetupGroupsInsert should not work without connection");
            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsInsert(_user, con, null);
            Assert.IsTrue(0 != hr, "TestSetupGroupsInsert should not work without record to insert");

            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsUpdate(null, con, groupToInsert);
            Assert.IsTrue(0 != hr, "TestSetupGroupsUpdate should not work without user");
            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsInsert(_user, null, groupToInsert);
            Assert.IsTrue(0 != hr, "TestSetupGroupsUpdate should not work without connection");
            hr = DbAPI.DbAPI.TestSetups.TestSetupGroupsInsert(_user, con, null);
            Assert.IsTrue(0 != hr, "TestSetupGroupsUpdate should not work without record to insert");
        }
    }
}