using DTS.Common.Classes.Tags;
using DTS.Common.Interface.Sensors;
using DTS.Common.Interface.Tags;
using DTS.Common.Interface.TestSetups.TestSetupsList;
using NUnit.Framework;
using System;
using System.Linq;

namespace DatabaseUnitTesting
{
    [TestFixture]
    public partial class DBAPITests
    {
        [Test]
        public void TagsTestGetNegatives()
        {
            if (!_setup) { Setup(); }
            TestLogin();
            var connections = DbAPI.DbAPI.Connections.GetActiveConnections();
            var tag = CreateFakeTag();

            //insert a tag just so that we have something that _might_ be returned
            var hr = DbAPI.DbAPI.Tags.TagsInsert(_user, connections.First(), ref tag);
            Assert.IsTrue(0 == hr, "TagsInsert returned 0");

            hr = DbAPI.DbAPI.Tags.TagsGet(null, connections.First(), null, out var records);
            Assert.IsTrue(0 != hr && (null == records || 0 == records.Length), "TagsGet should not allow null user");
            hr = DbAPI.DbAPI.Tags.TagsGet(_user, null, null, out records);
            Assert.IsTrue(0 != hr && (null == records || 0 == records.Length), "TagsGet should not allow null connection");
            hr = DbAPI.DbAPI.Tags.TagsGetId(null, connections.First(), tag.Text, out var id);
            Assert.IsTrue(0 != hr && null == id, "TagsGetId should not allow null user");
            hr = DbAPI.DbAPI.Tags.TagsGetId(_user, null, tag.Text, out id);
            Assert.IsTrue(0 != hr && null == id, "TagsGetId should not allow null connection");

            ITag tag2 = null;
            hr = DbAPI.DbAPI.Tags.TagsInsert(_user, connections.First(), ref tag2);
            Assert.IsTrue(DbAPI.Errors.ErrorCodes.ERROR_MISSING_PARAMETER == hr, "TagsInsert with null does return missing parameter");

            hr = DbAPI.DbAPI.Tags.TagsDelete(null, connections.First(), tag.ID);
            Assert.IsTrue(0 != hr, "TagsDelete should not allow null user");
            hr = DbAPI.DbAPI.Tags.TagsDelete(_user, null, tag.ID);
            Assert.IsTrue(0 != hr, "TagsDelete should not allow null connection");

            hr = DbAPI.DbAPI.Tags.TagsDelete(_user, connections.First(), tag.ID);
            Assert.IsTrue(0 == hr, "TagsDelete returns 0");
        }
        [Test]
        public void TagsTestGetPositives()
        {
            if (!_setup) { Setup(); }
            TestLogin();
            var connections = DbAPI.DbAPI.Connections.GetActiveConnections();
            var tag = CreateFakeTag();
            var hr = DbAPI.DbAPI.Tags.TagsGet(_user, connections.First(), null, out var records);
            Assert.IsTrue(0 == hr && (null == records || !records.Any(r => r.Text == tag.Text)),
                "TagsGet returns 0 and GUID text not already found");
            hr = DbAPI.DbAPI.Tags.TagsInsert(_user, connections.First(), ref tag);
            Assert.IsTrue(0 == hr && -1 != tag.ID, "TagsInsert returns 0 and modifies id");
            hr = DbAPI.DbAPI.Tags.TagsGet(_user, connections.First(), null, out records);
            Assert.IsTrue(0 == hr && null != records && records.Any(r => r.Text == tag.Text && r.ID == tag.ID),
                "TagsGet returns 0 and finds the tag");
            hr = DbAPI.DbAPI.Tags.TagsGet(_user, connections.First(), tag.ID, out records);
            Assert.IsTrue(0 == hr && null != records && records.Length == 1 && TagIsEqual(records[0], tag)
                , "TagsGet returns 0, and returns the tag [when passing in id]");
            hr = DbAPI.DbAPI.Tags.TagsGetId(_user, connections.First(), tag.Text, out var id);
            Assert.IsTrue(0 == hr && null != id && (int)id == tag.ID, "TagsGetId returns 0 and retrieves right id");
            hr = DbAPI.DbAPI.Tags.TagsDelete(_user, connections.First(), tag.ID);
            Assert.IsTrue(0 == hr, "TagsDelete returns 0");
            hr = DbAPI.DbAPI.Tags.TagsGet(_user, connections.First(), null, out records);
            Assert.IsTrue(0 == hr && null == records || !records.Any(r => r.Text == tag.Text), "TagsDelete returns 0");
        }
        private bool TagIsEqual(ITag left, ITag right)
        {
            return left.ID == right.ID &&
                left.IsObsolete == right.IsObsolete &&
                left.Text.Equals(right.Text);
        }
        public static ITag CreateFakeTag()
        {
            var tag = new Tag();
            tag.ID = -1;
            tag.Text = Guid.NewGuid().ToString().Substring(0, 15);
            return tag;
        }
        [Test]
        public void TagAssignmentsPositives()
        {
            if (!_setup) { Setup(); }
            TestLogin();
            var connections = DbAPI.DbAPI.Connections.GetActiveConnections();
            var tag = CreateFakeTag();

            _ = DbAPI.DbAPI.Tags.TagsInsert(_user, connections.First(), ref tag);

            var testSetup = CreateFakeTestSetup();
            _ = DbAPI.DbAPI.TestSetups.TestSetupsUpdateInsert(_user, connections.First(), 0, ref testSetup);
            var sensor = CreateFakeSensor();
            _ = DbAPI.DbAPI.Sensors.SensorsAnalogUpdateInsert(_user, connections.First(), sensor);

            var hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(_user, connections.First(), null, out var tagAssignments);
            Assert.IsTrue(0 == hr, "TagAssignmentsGet returns 0");

            var taTestSetup = CreateTagAssignment(tag, testSetup);
            hr = DbAPI.DbAPI.Tags.TagAssignmentsInsert(_user, connections.First(), taTestSetup);
            Assert.IsTrue(0 == hr, "TagAssignmentsInsert returns 0");

            var taSensor = CreateTagAssignment(tag, sensor);
            hr = DbAPI.DbAPI.Tags.TagAssignmentsInsert(_user, connections.First(), taSensor);
            Assert.IsTrue(0 == hr, "TagAssignmentsInsert returns 0");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(_user, connections.First(), null, out tagAssignments);
            Assert.IsTrue(0 == hr && null != tagAssignments &&
                tagAssignments.Any(t => IsTagAssignmentEqual(t, taTestSetup)) &&
                tagAssignments.Any(t => IsTagAssignmentEqual(t, taSensor)),
                "TagAssignmentsGet returns tag assignments");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(_user, connections.First(), TagTypes.TestSetup, out tagAssignments);
            Assert.IsTrue(0 == hr && null != tagAssignments && tagAssignments.Any(t => IsTagAssignmentEqual(t, taTestSetup)),
                "TagAssignmentsGet returns taTestSetup");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(_user, connections.First(), TagTypes.Sensors, out tagAssignments);
            Assert.IsTrue(0 == hr && null != tagAssignments && tagAssignments.Any(t => IsTagAssignmentEqual(t, taSensor)),
                "TagAssignmentsGet returns taSensor");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsDelete(_user, connections.First(), taSensor.ObjectID, TagTypes.Sensors);
            Assert.IsTrue(0 == hr, "TagAssignmentsDelete returns 0");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsDelete(_user, connections.First(), taTestSetup.ObjectID, TagTypes.TestSetup);
            Assert.IsTrue(0 == hr, "TagAssignmentsDelete returns 0");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(_user, connections.First(), null, out tagAssignments);
            Assert.IsTrue(0 == hr && !tagAssignments.Any(t => IsTagAssignmentEqual(t, taSensor))
                && !tagAssignments.Any(t => IsTagAssignmentEqual(t, taTestSetup)), "TagAssignments deleted");
            _ = DbAPI.DbAPI.Tags.TagsDelete(_user, connections.First(), tag.ID);

            _ = DbAPI.DbAPI.Sensors.SensorsDelete(_user, connections.First(), sensor.Id, 0);
            _ = DbAPI.DbAPI.TestSetups.TestSetupsDeleteById(_user, connections.First(), new[] { testSetup.Id });
        }

        private bool IsTagAssignmentEqual(ITagAssignment left, ITagAssignment right)
        {
            return left.ObjectID == right.ObjectID
                && left.ObjectType == right.ObjectType
                && left.TagID == right.TagID;
        }
        private ITagAssignment CreateTagAssignment(ITag tag, IAnalogDbRecord sensor)
        {
            var ta = new TagAssignment() { ObjectType = TagTypes.Sensors, TagID = tag.ID, ObjectID = sensor.Id };
            return ta;
        }
        private ITagAssignment CreateTagAssignment(ITag tag, ITestSetupRecord test)
        {
            var ta = new TagAssignment() { ObjectID = test.Id, ObjectType = TagTypes.TestSetup, TagID = tag.ID };
            return ta;
        }

        [Test]
        public void TagAssignmentsNegatives()
        {
            if (!_setup) { Setup(); }
            TestLogin();
            var con = DbAPI.DbAPI.Connections.GetActiveConnections().First();
            var tag = CreateFakeTag();

            _ = DbAPI.DbAPI.Tags.TagsInsert(_user, con, ref tag);

            var hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(null, con, null, out var tagAssignments);
            Assert.IsTrue(0 != hr, "TagAssignmentsGet should not work with null user");
            hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(_user, null, null, out tagAssignments);
            Assert.IsTrue(0 != hr, "TagAssignmentsGet should not work with null connection");
            var sensor = CreateFakeSensor();
            _ = DbAPI.DbAPI.Sensors.SensorsAnalogUpdateInsert(_user, con, sensor);
            var testSetup = CreateFakeTestSetup();
            _ = DbAPI.DbAPI.TestSetups.TestSetupsUpdateInsert(_user, con, 0, ref testSetup);

            var taSetup = CreateTagAssignment(tag, testSetup);
            var taSensor = CreateTagAssignment(tag, sensor);

            hr = DbAPI.DbAPI.Tags.TagAssignmentsInsert(null, con, taSetup);
            Assert.IsTrue(0 != hr, "TagAssignmentsInsert should not work with null user");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsInsert(_user, null, taSetup);
            Assert.IsTrue(0 != hr, "TagAssignmentsInsert should not work with null connection");

            hr = DbAPI.DbAPI.Tags.TagAssignmentsInsert(_user, con, null);
            Assert.IsTrue(DbAPI.Errors.ErrorCodes.ERROR_MISSING_PARAMETER == hr, "TagAssignmentsInsert should not work with null tagassignment");

            hr = DbAPI.DbAPI.TestSetups.TestSetupsDeleteById(_user, con, new[] { testSetup.Id });
            Assert.IsTrue(0 == hr, "TestSetupsDelete should work when tag assignments exist");

            hr = DbAPI.DbAPI.Sensors.SensorsDelete(_user, con, sensor.Id, 0);
            Assert.IsTrue(0 == hr, "SensorsDelete should work when tag assignments exist");

            var sensor2 = CreateFakeSensor();
            _ = DbAPI.DbAPI.Sensors.SensorsAnalogUpdateInsert(_user, con, sensor);
            var taSensor2 = CreateTagAssignment(tag, sensor2);
            _ = DbAPI.DbAPI.Tags.TagAssignmentsInsert(_user, con, taSensor2);

            hr = DbAPI.DbAPI.Tags.TagsDelete(_user, con, tag.ID);
            Assert.IsTrue(0 == hr, "TagsDelete should work when tag assignments exist");
            _ = DbAPI.DbAPI.Sensors.SensorsDelete(_user, con, sensor2.Id, 0);
        }
    }
}