using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;

namespace ChemicalRegex
{
    public class DmObject : ReadOnlyDictionary<string, object>
    {
        public DmObject(StreamReader text) : base(new Dictionary<string, object>(Assignments(text))) { }

        private static IEnumerable<KeyValuePair<string, object>> Assignments(StreamReader text)
        {
            var isNotDataObject = false;
            foreach (var rawLine in Lines(text))
            {
                Console.WriteLine($"    {rawLine}");
                if (rawLine.StartsWith("/datum/"))
                {
                    yield break;
                }

                if (rawLine.StartsWith("/obj/"))
                {
                    isNotDataObject = true;
                }

                if (isNotDataObject)
                {
                    continue;
                }

                if (rawLine.Length == 0 ||
                    rawLine.StartsWith("\t\t") ||
                    rawLine.StartsWith("     ") ||
                    rawLine.TrimStart().StartsWith("if") ||
                    rawLine.TrimStart().StartsWith("for"))
                {
                    continue;
                }

                var line = new StringBuilder(rawLine);

                var commentIndex = rawLine.IndexOf("//", StringComparison.Ordinal);
                if (commentIndex != -1)
                {
                    line.Remove(commentIndex, line.Length - commentIndex);
                }

                var assIn = line.ToString().IndexOf('=');
                if (assIn != -1)
                {
                    var assLeft = line.ToString(0, assIn).Trim().Trim('"');
                    var assRight = line.ToString(assIn + 1, line.Length - (assIn + 1)).Trim().Trim('"');
                    yield return KeyValuePair.Create(assLeft, ParseLiteral(assRight));
                }
            }
        }

        private static object ParseLiteral(string rawLiteral)
        {
            var literal = new StringBuilder(rawLiteral);

            if (int.TryParse(rawLiteral, out var result))
            {
                return result;
            }
            else if (rawLiteral.StartsWith("list"))
            {
                literal.Remove(0, rawLiteral.IndexOf('('));
                literal.Remove(literal.Length - 1, 1);

                return new Dictionary<string, object>(
                    literal.ToString()
                        .Split(',')
                        .Select(l =>
                        {
                            var succ = TryParseAssignment(l, out var ass);
                            return (succ, ass);
                        })
                        .Where(x => x.succ)
                        .Select(x => x.ass));
            }

            return rawLiteral;
        }

        private static bool TryParseAssignment(string assignment, out KeyValuePair<string, object> result)
        {
            var assIn = assignment.IndexOf('=');
            if (assIn != -1)
            {
                var assLeft = assignment.Substring(0, assIn).Trim();
                var assRight = assignment.Substring(assIn + 1, assignment.Length - (assIn + 1)).Trim();
                result = KeyValuePair.Create(assLeft, ParseLiteral(assRight));
                return true;
            }

            result = default;
            return false;
        }

        private static IEnumerable<string> Lines(StreamReader sr)
        {
            while (!sr.EndOfStream)
            {
                yield return sr.ReadLine();
            }
        }
    }
}