using System;

namespace Vellum.UnitTests
{
    public class Creature
    {
        public string Name;
    }

    public class Wolf : Creature
    {
    }

    public class AlphaWolf : Wolf
    {
    }

    public abstract class AbstractCreature : Creature
    {
    }

    public class Mastiff : AbstractCreature
    {
    }

    public class Herd<MemberType>
    {
        public MemberType Lead;
    }

    public class IntHerd : Herd<int>
    {
    }

    public class StringHerd : Herd<string>
    {
    }

    public class LabeledHerd<LabelType, MemberType> : Herd<MemberType>
    {
        public LabelType Label;
    }

    public class NameHerd : LabeledHerd<double, string>
    {
    }

    // The generator reports each, and the pragma silences what it says.
#pragma warning disable VEL0002, VEL0007
    /// <summary>
    /// Counts the converters made for each closed type, since a static in a generic class is one per closed type.
    /// </summary>
    public class CreatureConverter<CreatureType> : SaveConverter<CreatureType>
        where CreatureType : Creature
    {
        public static int Made;

        public CreatureConverter()
        {
            ++Made;
        }

        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.OfText(value.Name);
        }

        public override CreatureType Read(SaveNode node, SaveSession session)
        {
            var returnMe = (CreatureType)Activator.CreateInstance(typeof(CreatureType));
            returnMe.Name = node.RequireText();
            return returnMe;
        }
    }

    public class WolfConverter<WolfType> : SaveConverter<WolfType>
        where WolfType : Wolf
    {
        public override SaveNode Write(WolfType value, SaveSession session)
        {
            return SaveNode.OfText("wolf " + value.Name);
        }

        public override WolfType Read(SaveNode node, SaveSession session)
        {
            var returnMe = (WolfType)Activator.CreateInstance(typeof(WolfType));
            returnMe.Name = node.RequireText().Substring("wolf ".Length);
            return returnMe;
        }
    }

    public class HerdConverter<HerdType, MemberType> : SaveConverter<HerdType>
        where HerdType : Herd<MemberType>
    {
        public override SaveNode Write(HerdType value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["lead"] = session.ToNode(value.Lead, typeof(MemberType));
            return returnMe;
        }

        public override HerdType Read(SaveNode node, SaveSession session)
        {
            var returnMe = (HerdType)Activator.CreateInstance(typeof(HerdType));
            returnMe.Lead = (MemberType)session.FromNode(node.RequireEntry("lead"), typeof(MemberType));
            return returnMe;
        }
    }

    public class StructLabeledHerdConverter<HerdType, LabelType, MemberType> : SaveConverter<HerdType>
        where HerdType : LabeledHerd<LabelType, MemberType>
        where MemberType : struct
    {
        public override SaveNode Write(HerdType value, SaveSession session)
        {
            return SaveNode.OfText("struct labeled herd");
        }

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

    public class StructHerdConverter<HerdType, MemberType> : SaveConverter<HerdType>
        where HerdType : Herd<MemberType>
        where MemberType : struct
    {
        public override SaveNode Write(HerdType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class ThrowingCreatureConverter<CreatureType> : SaveConverter<CreatureType>
        where CreatureType : Creature
    {
        public ThrowingCreatureConverter()
        {
            throw new FormatException("no converter for you");
        }

        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class ThrowingBoxConverter<ItemType> : SaveConverter<Box<ItemType>>
    {
        public ThrowingBoxConverter()
        {
            throw new FormatException("no converter for you");
        }

        public override SaveNode Write(Box<ItemType> value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override Box<ItemType> Read(SaveNode node, SaveSession session)
        {
            return null;
        }
    }

    public class TwoConstraintFamilyConverter<CreatureType> : SaveConverter<CreatureType>
        where CreatureType : Creature, IDisposable
    {
        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class ClassConstrainedFamilyConverter<CreatureType> : SaveConverter<CreatureType>
        where CreatureType : class
    {
        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class NewConstrainedFamilyConverter<CreatureType> : SaveConverter<CreatureType>
        where CreatureType : Creature, new()
    {
        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class InterfaceFamilyConverter<DisposableType> : SaveConverter<DisposableType>
        where DisposableType : ICloneable
    {
        public override SaveNode Write(DisposableType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class ParameterConstrainedFamilyConverter<CreatureType, BaseType> : SaveConverter<CreatureType>
        where CreatureType : BaseType
    {
        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class UnboundFamilyConverter<CreatureType, ExtraType> : SaveConverter<CreatureType>
        where CreatureType : Creature
    {
        public override SaveNode Write(CreatureType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class SelfReferencingFamilyConverter<HerdType> : SaveConverter<HerdType>
        where HerdType : Herd<HerdType>
    {
        public override SaveNode Write(HerdType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class ClosedBaseFamilyConverter<HerdType> : SaveConverter<HerdType>
        where HerdType : Herd<int>
    {
        public override SaveNode Write(HerdType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class RepeatedBaseArgumentFamilyConverter<HerdType, MemberType> : SaveConverter<HerdType>
        where HerdType : Pairing<MemberType, MemberType>
    {
        public override SaveNode Write(HerdType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

#pragma warning restore VEL0002, VEL0007

    public class Pairing<FirstType, SecondType>
    {
    }
}