using System.Collections.Generic;

namespace Vellum.UnitTests
{
    [Saveable]
    public partial struct Vector
    {
        public double X;
        public double Y;

        [NoSave]
        public double Length;
    }

    [Saveable]
    public readonly partial struct Fixed
    {
        public readonly int Count;

        public string Label { get; }

        public Fixed(int count, string label)
        {
            Count = count;
            Label = label;
        }
    }

    /// <summary>
    /// Holds another [Saveable] type, private and keyword-named fields, and a parameterless constructor that sets a
    /// field.
    /// </summary>
    [Saveable]
    public sealed partial class Crate
    {
        public string Name = "unnamed";

        public Vector At;

        public Crate Inside;

        public int @event;

        public int Opened;

        private int secret = 3;

        public Crate()
        {
            Opened = -1;
        }

        public int Secret
        {
            get
            {
                return secret;
            }
        }

        public void Hide(int value)
        {
            secret = value;
        }
    }

    [Saveable]
    public sealed partial class WithoutParameterlessConstructor
    {
        public int Value = 5;

        public int Other;

        public WithoutParameterlessConstructor(int other)
        {
            Other = other;
        }
    }

    [Saveable]
    public sealed partial class WithImplicitConstructor
    {
        public int Value = 5;
    }

    /// <summary>
    /// Loads every field, then adjusts one.
    /// </summary>
    [Saveable]
    public sealed partial class Shouting
    {
        public string Label = "";

        private Shouting(SaveReader reader)
            : this(reader, default(AutoLoadEveryField))
        {
            Label = Label.ToUpperInvariant();
        }

        public Shouting()
        {
        }
    }

    /// <summary>
    /// Loads nothing that was saved.
    /// </summary>
    [Saveable]
    public sealed partial class Forgetful
    {
        public int Count;

        private Forgetful(SaveReader reader)
        {
            Count = 42;
        }

        public Forgetful()
        {
        }
    }

    [Saveable]
    public abstract partial class Beast
    {
        public string Name = "";
    }

    [Saveable]
    public partial class Hound : Beast
    {
        public bool Barks;

        public Beast Prey;
    }

    [Saveable]
    public sealed partial class Puppy : Hound
    {
        public int Weeks;
    }

    [Saveable]
    public sealed partial class Kitten : Beast
    {
        public int Lives = 9;
    }

    /// <summary>
    /// Has no [Saveable] of its own.
    /// </summary>
    public sealed partial class Wolfhound : Hound
    {
        public int Height;
    }

    [Saveable]
    public interface ICreature
    {
    }

    public interface IFlyer : ICreature
    {
    }

    public sealed partial class Dragon : IFlyer
    {
        public string Name = "";

        public int Wingspan;
    }

    public partial struct Sprite : ICreature
    {
        public int Glow;
    }

    [Saveable]
    public sealed partial class Menagerie
    {
        public ICreature Star;

        public ICreature Empty;

        public List<ICreature> Cages = new List<ICreature>();
    }

    [Saveable]
    public sealed partial class Folder
    {
        public string Name = "";

        public Folder Parent;

        public List<Folder> Children = new List<Folder>();
    }

    [Saveable]
    public sealed partial class Kennel
    {
        public Beast Resident;

        public List<Beast> Pack = new List<Beast>();
    }

    [Saveable]
    public partial class Moody
    {
        public int Mood;

        protected Moody(SaveReader reader)
            : this(reader, default(AutoLoadEveryField))
        {
            Mood += 100;
        }

        public Moody()
        {
        }
    }

    [Saveable]
    public sealed partial class Grumpy : Moody
    {
        public int Grumbles;
    }

    public partial class Outer
    {
        [Saveable]
        public partial struct Inner
        {
            public int Value;
        }
    }

    public static partial class StaticOuter
    {
        [Saveable]
        public partial struct Inner
        {
            public int Value;
        }
    }

    [Saveable]
    public sealed partial class Chained
    {
        public Chained Next;
    }

    [Saveable]
    public partial struct Duo<A, B>
        where A : struct
    {
        public A First;
        public B Second;
    }

    [Saveable]
    public abstract partial class Vessel<CargoType>
    {
        public CargoType Cargo;
    }

    [Saveable]
    public sealed partial class Barge : Vessel<string>
    {
        public int Draft;
    }

    [Saveable]
    public sealed partial class Freighter<CrateType> : Vessel<List<CrateType>>
    {
        public int Tonnage;
    }

    [Saveable]
    public interface ILabelled
    {
    }

    public partial struct Tag<ItemType> : ILabelled
    {
        public ItemType Item;
    }

    [Saveable]
    public sealed partial class Fleet
    {
        public Vessel<string> Plain;

        public Vessel<List<int>> Loaded;

        public ILabelled Label;
    }

    public partial class Crate<ContentType>
    {
        [Saveable]
        public partial struct Label
        {
            public ContentType Content;

            public int Copies;
        }

        public partial class Shelf<ShelfType>
        {
            [Saveable]
            public sealed partial class Slot<SlotType>
            {
                public ContentType Content;

                public ShelfType Shelf;

                public SlotType Held;
            }
        }
    }

    [Saveable]
    public sealed partial class Grid<CellType>
    {
        public int Width;

        public List<CellType> Cells = new List<CellType>();
    }

    /// <summary>
    /// Holds one of each collection Vellum saves, some of them holding another saved type.
    /// </summary>
    [Saveable]
    public sealed partial class Cargo
    {
        public List<Vector> Route = new List<Vector>();

        public int[] Counts = new int[0];

        public Dictionary<string, HashSet<string>> Tags = new Dictionary<string, HashSet<string>>();

        public Dictionary<Vector, string> Names = new Dictionary<Vector, string>();

        public Queue<Vector> Line = new Queue<Vector>();

        public Stack<string> Pile = new Stack<string>();

        public int[,] Grid = new int[0, 0];

        public LinkedList<string> Chain = new LinkedList<string>();

        public SortedDictionary<string, int> Tally = new SortedDictionary<string, int>();

        public SortedSet<int> Marks = new SortedSet<int>();

        public double[,,,] Cube = new double[0, 0, 0, 0];
    }

    /// <summary>
    /// A hierarchy with a member that isn't built in at every level.
    /// </summary>
    [Saveable]
    public abstract partial class Shipment
    {
        public Crate Top;

        public int Weight;
    }

    [Saveable]
    public partial class Pallet : Shipment
    {
        public List<Crate> Crates = new List<Crate>();
    }

    [Saveable]
    public sealed partial class Truck : Pallet
    {
        public Crate Spare;

        public string Plate = "";
    }

    /// <summary>
    /// Holds a struct that holds an object, so a failure inside the object passes through the struct's key.
    /// </summary>
    [Saveable]
    public sealed partial class Pairing
    {
        public Duo<Vector, Crate> Pair;
    }
}