namespace Vellum.UnitTests
{
    public interface ICarnivore
    {
    }

    public interface IPredator : ICarnivore
    {
    }

    public interface IAquatic
    {
    }

    public interface IVessel<ItemType>
    {
    }

    // The generator reports the types that two unrelated interface families both save, and the pragma silences it.
#pragma warning disable VEL0014, VEL0015
    public class Shark : ICarnivore, IAquatic
    {
    }

    public class Lynx : ICarnivore
    {
    }

    public class Gryphon : Creature, ICarnivore
    {
    }

    public class Orca : IPredator
    {
    }

    public class Otter : IAquatic
    {
    }

    public struct Sprat : IAquatic
    {
    }

    public abstract class AbstractAquatic : IAquatic
    {
    }

    public class Cod : AbstractAquatic
    {
    }

    public class Barrel : IVessel<int>
    {
    }

    public class Twin : IVessel<int>, IVessel<string>
    {
    }
#pragma warning restore VEL0014, VEL0015

    public class CarnivoreConverter<CarnivoreType> : SaveConverter<CarnivoreType>
        where CarnivoreType : ICarnivore
    {
        public override SaveNode Write(CarnivoreType value, SaveSession session)
        {
            return SaveNode.OfText("carnivore");
        }

        public override CarnivoreType Read(SaveNode node, SaveSession session)
        {
            return (CarnivoreType)System.Activator.CreateInstance(typeof(CarnivoreType));
        }
    }

    public class PredatorConverter<PredatorType> : SaveConverter<PredatorType>
        where PredatorType : IPredator
    {
        public override SaveNode Write(PredatorType value, SaveSession session)
        {
            return SaveNode.OfText("predator");
        }

        public override PredatorType Read(SaveNode node, SaveSession session)
        {
            return (PredatorType)System.Activator.CreateInstance(typeof(PredatorType));
        }
    }

    public class AquaticConverter<AquaticType> : SaveConverter<AquaticType>
        where AquaticType : IAquatic
    {
        public override SaveNode Write(AquaticType value, SaveSession session)
        {
            return SaveNode.OfText("aquatic");
        }

        public override AquaticType Read(SaveNode node, SaveSession session)
        {
            return (AquaticType)System.Activator.CreateInstance(typeof(AquaticType));
        }
    }

    /// <summary>
    /// A family of an interface every built-in type implements. It and its twin below are duplicates on purpose, so
    /// the generator leaves both out of the assembly's converters and only tests that ask for it get either.
    /// </summary>
#pragma warning disable VEL0002
    public class ComparableTwinConverter<ComparableType> : SaveConverter<ComparableType>
        where ComparableType : System.IComparable
    {
        public override SaveNode Write(ComparableType value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override ComparableType Read(SaveNode node, SaveSession session)
        {
            return default(ComparableType);
        }
    }

    public class ComparableConverter<ComparableType> : SaveConverter<ComparableType>
        where ComparableType : System.IComparable
    {
        public override SaveNode Write(ComparableType value, SaveSession session)
        {
            return SaveNode.OfText("comparable");
        }

        public override ComparableType Read(SaveNode node, SaveSession session)
        {
            return default(ComparableType);
        }
    }

#pragma warning restore VEL0002

    public class VesselConverter<VesselType, ItemType> : SaveConverter<VesselType>
        where VesselType : IVessel<ItemType>
    {
        public override SaveNode Write(VesselType value, SaveSession session)
        {
            return SaveNode.OfText("vessel of " + typeof(ItemType).Name);
        }

        public override VesselType Read(SaveNode node, SaveSession session)
        {
            return (VesselType)System.Activator.CreateInstance(typeof(VesselType));
        }
    }
}