using System;
using System.Collections.Generic;
using System.IO;

namespace Vellum.UnitTests
{
    public struct Point
    {
        public double X;
        public double Y;

        public Point(double x, double y)
        {
            X = x;
            Y = y;
        }
    }

    public class PointConverter : SaveConverter<Point>
    {
        public override SaveNode Write(Point value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["x"] = session.ToNode(value.X);
            returnMe.Entries["y"] = session.ToNode(value.Y);
            return returnMe;
        }

        public override Point Read(SaveNode node, SaveSession session)
        {
            return new Point(session.FromNode<double>(node.RequireEntry("x")),
                session.FromNode<double>(node.RequireEntry("y")));
        }
    }

    /// <summary>
    /// A reference type whose converter saves another converted type inside it.
    /// </summary>
    public class Waypoint
    {
        public string Name;
        public Point At;
    }

    public class WaypointConverter : SaveConverter<Waypoint>
    {
        public override SaveNode Write(Waypoint value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["name"] = session.ToNode(value.Name);
            returnMe.Entries["at"] = session.ToNode(value.At);
            return returnMe;
        }

        public override Waypoint Read(SaveNode node, SaveSession session)
        {
            return new Waypoint
            {
                Name = session.FromNode<string>(node.RequireEntry("name")),
                At = session.FromNode<Point>(node.RequireEntry("at")),
            };
        }
    }

    /// <summary>
    /// A type that can contain itself, to drive deep nesting.
    /// </summary>
    public class Link
    {
        public Link Next;
    }

    public class LinkConverter : SaveConverter<Link>
    {
        public override SaveNode Write(Link value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["next"] = session.ToNode(value.Next, typeof(Link));
            return returnMe;
        }

        public override Link Read(SaveNode node, SaveSession session)
        {
            return new Link { Next = (Link)session.FromNode(node.RequireEntry("next"), typeof(Link)) };
        }
    }

    /// <summary>
    /// A struct that holds a link, to drive deep nesting and cycles through a struct saved on its own.
    /// </summary>
    public struct LinkHolder
    {
        public Link Head;
    }

    public class LinkHolderConverter : SaveConverter<LinkHolder>
    {
        public override SaveNode Write(LinkHolder value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["head"] = session.ToNode(value.Head);
            return returnMe;
        }

        public override LinkHolder Read(SaveNode node, SaveSession session)
        {
            return new LinkHolder { Head = session.FromNode<Link>(node.RequireEntry("head")) };
        }
    }

    /// <summary>
    /// A struct whose converter always fails, to check what saving one leaves behind.
    /// </summary>
    public struct FaultyStruct
    {
    }

    public class FaultyStructConverter : SaveConverter<FaultyStruct>
    {
        public override SaveNode Write(FaultyStruct value, SaveSession session)
        {
            throw new InvalidOperationException("This struct can't be saved.");
        }

        public override FaultyStruct Read(SaveNode node, SaveSession session)
        {
            throw new InvalidDataException("This struct can't be loaded.");
        }
    }

    /// <summary>
    /// A type whose converter makes up a new one each time, so saving it never ends.
    /// </summary>
    public class Endless
    {
    }

    public class EndlessConverter : SaveConverter<Endless>
    {
        public override SaveNode Write(Endless value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["next"] = session.ToNode(new Endless(), typeof(Endless));
            return returnMe;
        }

        public override Endless Read(SaveNode node, SaveSession session)
        {
            return new Endless();
        }
    }

    // Several of the generic converters below are mis-shaped or in conflict on purpose, to test how Vellum treats them.
    // The generator reports each, and the pragma silences what it says.
#pragma warning disable VEL0002, VEL0003, VEL0007

    /// <summary>
    /// A generic reference type, to drive converters that are closed over their type argument on first use.
    /// </summary>
    public class Box<ItemType>
    {
        public ItemType Content;
    }

    public class BoxConverter<ItemType> : SaveConverter<Box<ItemType>>
    {
        public override SaveNode Write(Box<ItemType> value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["content"] = session.ToNode(value.Content, typeof(ItemType));
            return returnMe;
        }

        public override Box<ItemType> Read(SaveNode node, SaveSession session)
        {
            return new Box<ItemType>
            {
                Content = (ItemType)session.FromNode(node.RequireEntry("content"), typeof(ItemType)),
            };
        }
    }

    public struct Pair<FirstType, SecondType>
    {
        public FirstType First;
        public SecondType Second;
    }

    /// <summary>
    /// Declares its type parameters in the opposite order from the pair it converts, so mixing the two up shows.
    /// </summary>
    public class PairConverter<[Saveable] SecondType, [Saveable] FirstType>
        : SaveConverter<Pair<FirstType, SecondType>>
    {
        public override SaveNode Write(Pair<FirstType, SecondType> value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["first"] = session.ToNode(value.First, typeof(FirstType));
            returnMe.Entries["second"] = session.ToNode(value.Second, typeof(SecondType));
            return returnMe;
        }

        public override Pair<FirstType, SecondType> Read(SaveNode node, SaveSession session)
        {
            return new Pair<FirstType, SecondType>
            {
                First = (FirstType)session.FromNode(node.RequireEntry("first"), typeof(FirstType)),
                Second = (SecondType)session.FromNode(node.RequireEntry("second"), typeof(SecondType)),
            };
        }
    }

    /// <summary>
    /// A generic type that can contain itself, to drive the converters' depth limit through a closed converter.
    /// </summary>
    public class Cell<ItemType>
    {
        public Cell<ItemType> Next;
    }

    public class CellConverter<ItemType> : SaveConverter<Cell<ItemType>>
    {
        public override SaveNode Write(Cell<ItemType> value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["next"] = session.ToNode(value.Next, typeof(Cell<ItemType>));
            return returnMe;
        }

        public override Cell<ItemType> Read(SaveNode node, SaveSession session)
        {
            return new Cell<ItemType>
            {
                Next = (Cell<ItemType>)session.FromNode(node.RequireEntry("next"), typeof(Cell<ItemType>)),
            };
        }
    }

    /// <summary>
    /// A type nested in a generic type, whose converter's type parameters are those of both types.
    /// </summary>
    public class Holder<OuterType>
    {
        public class Slot<InnerType>
        {
            public OuterType Outer;
            public InnerType Inner;
        }
    }

    public class SlotConverter<[Saveable] OuterType, [Saveable] InnerType>
        : SaveConverter<Holder<OuterType>.Slot<InnerType>>
    {
        public override SaveNode Write(Holder<OuterType>.Slot<InnerType> value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["outer"] = session.ToNode(value.Outer, typeof(OuterType));
            returnMe.Entries["inner"] = session.ToNode(value.Inner, typeof(InnerType));
            return returnMe;
        }

        public override Holder<OuterType>.Slot<InnerType> Read(SaveNode node, SaveSession session)
        {
            return new Holder<OuterType>.Slot<InnerType>
            {
                Outer = (OuterType)session.FromNode(node.RequireEntry("outer"), typeof(OuterType)),
                Inner = (InnerType)session.FromNode(node.RequireEntry("inner"), typeof(InnerType)),
            };
        }
    }

    /// <summary>
    /// A generic type that only takes value types, so closing it over anything else fails.
    /// </summary>
    public class Limited<ItemType>
        where ItemType : struct
    {
    }

    public enum Mood
    {
        Calm,
        Angry,
    }

    public class Palette
    {
        public enum Shade : byte
        {
            Light,
            Dark,
        }
    }

    public class Counted<ItemType>
    {
    }

    /// <summary>
    /// Counts the converters made for each closed type, since a static in a generic class is one per closed type.
    /// </summary>
    public class CountedConverter<ItemType> : SaveConverter<Counted<ItemType>>
    {
        public static int Made;

        public CountedConverter()
        {
            ++Made;
        }

        public override SaveNode Write(Counted<ItemType> value, SaveSession session)
        {
            return SaveNode.OfText("counted");
        }

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

    public class StructBoxConverter<ItemType> : SaveConverter<Box<ItemType>>
        where ItemType : struct
    {
        public override SaveNode Write(Box<ItemType> value, SaveSession session)
        {
            return SaveNode.OfText("struct box");
        }

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

    public abstract class AbstractBoxConverter<ItemType> : SaveConverter<Box<ItemType>>
    {
    }

    /// <summary>
    /// Converts only part of a generic type, which would claim every dictionary with string keys.
    /// </summary>
    public class PartlyClosedConverter<ItemType> : SaveConverter<Dictionary<string, ItemType>>
    {
        public override SaveNode Write(Dictionary<string, ItemType> value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class RepeatedParameterConverter<FirstType, SecondType> : SaveConverter<Pair<FirstType, FirstType>>
    {
        public override SaveNode Write(Pair<FirstType, FirstType> value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override Pair<FirstType, FirstType> Read(SaveNode node, SaveSession session)
        {
            return default(Pair<FirstType, FirstType>);
        }
    }

    /// <summary>
    /// Derives from the non-generic SaveConverter, so it names no type it converts.
    /// </summary>
    public class UntypedGenericConverter<ItemType> : SaveConverter
    {
        public override Type ValueType
        {
            get
            {
                return typeof(Box<ItemType>);
            }
        }

        public override SaveNode ToNode(object value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override object FromNode(SaveNode node, SaveSession session)
        {
            return null;
        }
    }

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

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

    public class ExtraParameterConverter<ItemType, OtherType> : SaveConverter<Box<ItemType>>
    {
        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 AnyTypeConverter<ItemType> : SaveConverter<ItemType>
    {
        public override SaveNode Write(ItemType value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class NullableOfAnyConverter<ItemType> : SaveConverter<ItemType?>
        where ItemType : struct
    {
        public override SaveNode Write(ItemType? value, SaveSession session)
        {
            return SaveNode.Null;
        }

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

    public class IntArrayConverter<ItemType> : SaveConverter<int[]>
    {
        public override SaveNode Write(int[] value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override int[] Read(SaveNode node, SaveSession session)
        {
            return null;
        }
    }

    public class ArrayOfParameterConverter<ItemType> : SaveConverter<ItemType[]>
    {
        public override SaveNode Write(ItemType[] value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override ItemType[] Read(SaveNode node, SaveSession session)
        {
            return null;
        }
    }

    public class MultiDimensionalConverter<ItemType> : SaveConverter<ItemType[,]>
    {
        public override SaveNode Write(ItemType[,] value, SaveSession session)
        {
            return SaveNode.Null;
        }

        public override ItemType[,] Read(SaveNode node, SaveSession session)
        {
            return null;
        }
    }

    /// <summary>
    /// Converts any type, for building converter sets by hand.
    /// </summary>
    public class StubConverter<T> : SaveConverter<T>
    {
        public override SaveNode Write(T value, SaveSession session)
        {
            return SaveNode.OfText("stub");
        }

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

#pragma warning restore VEL0002, VEL0003, VEL0007
}