using Salmon.Core;

namespace Salmon.Test
{
    [TestClass]
    public class TraductionTester
    {
        Salmon.Core.Cliff.Translator Translator { get; set; } = new();

        [TestMethod]
        public void TestEncoding()
        {
            var id = Guid.NewGuid().ToString();
            Element el = new Element(id)
            {
                ParentId = Guid.NewGuid().ToString(),
                Description = "description",
                ShortName = "short",
                LongName = "long",
            };

            var triplets = Translator.Encode(el).ToList();

            if (triplets.Count != 5)
                Assert.Fail("Bad triple count");

            foreach (Triplet t in triplets)
                Assert.AreEqual(t.key, id);

            Assert.AreEqual(triplets[0].key, id);
            Assert.AreEqual(triplets[0].predicate, Salmon.Core.Cliff.Translator.TYPE_PREDICATE);
            Assert.AreEqual(triplets[0].value, nameof(Element));

            Assert.AreEqual(triplets[1].key, id);
            Assert.AreEqual(triplets[1].predicate, "parent");
            Assert.AreEqual(triplets[1].value, el.ParentId);

            Assert.AreEqual(triplets[2].key, id);
            Assert.AreEqual(triplets[2].predicate, nameof(Element.ShortName));
            Assert.AreEqual(triplets[2].value, el.ShortName);

            Assert.AreEqual(triplets[3].key, id);
            Assert.AreEqual(triplets[3].predicate, nameof(Element.LongName));
            Assert.AreEqual(triplets[3].value, el.LongName);

            Assert.AreEqual(triplets[4].key, id);
            Assert.AreEqual(triplets[4].predicate, nameof(Element.Description));
            Assert.AreEqual(triplets[4].value, el.Description);
        }

        [TestMethod]
        public void TestDecoding()
        {
            string id = Guid.NewGuid().ToString();
            string parentid = Guid.NewGuid().ToString();
            string shortName = "short";
            string longName = "long";
            string description = "description";

            List<Triplet> triplets = new()
            {
                new Triplet
                {
                    key = id,
                    predicate = Salmon.Core.Cliff.Translator.TYPE_PREDICATE,
                    value = nameof(Element)
                },
                new Triplet
                {
                    key = id,
                    predicate = "parent",
                    value = parentid
                },
                new Triplet
                {
                    key = id,
                    predicate = nameof(Element.ShortName),
                    value = shortName
                },
                new Triplet
                {
                    key = id,
                    predicate = nameof(Element.LongName), 
                    value = longName
                },
                new Triplet
                {
                    key = id,
                    predicate = nameof(Element.Description),
                    value = description
                }
            };

            var el = Translator.Decode<Element>(triplets);

            Assert.AreEqual(el.UniqueId, id);
            Assert.AreEqual(el.ParentId, parentid);
            Assert.AreEqual(el.ShortName, shortName);
            Assert.AreEqual(el.LongName, longName);
            Assert.AreEqual(el.Description, description);
        }
    }
}