ScriptFile.cs

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

namespace PresentationPrompter
{
    public static class ScriptFile
    {
        public static ScriptLoadResult Load(string path)
        {
            if (!File.Exists(path))
                return null;

            try
            {
                if (path.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
                    return LoadFromJson(path);
                else
                    return LoadFromTxt(path);
            }
            catch
            {
                return null;
            }
        }

        public static ScriptLoadResult LoadFromTxt(string path)
        {
            string[] lines = File.ReadAllLines(path, Encoding.UTF8);
            if (lines.Length < 2)
                return null;

            var result = new ScriptLoadResult();
            result.Title = lines[0];
            result.Steps = new ScriptStep[lines.Length - 1];
            for (int i = 1; i < lines.Length; i++)
                result.Steps[i - 1] = new ScriptStep(lines[i]);

            return result;
        }

        public static ScriptLoadResult LoadFromJson(string path)
        {
            string json = File.ReadAllText(path, Encoding.UTF8);
            var reader = new JsonReader(json);
            var obj = reader.ParseObject();

            var result = new ScriptLoadResult();
            result.Title = obj.GetString("title", "");

            var stepsArr = obj.GetArray("steps");
            if (stepsArr == null || stepsArr.Count == 0)
                return null;

            result.Steps = new ScriptStep[stepsArr.Count];
            for (int i = 0; i < stepsArr.Count; i++)
            {
                var stepObj = stepsArr.GetObject(i);
                result.Steps[i] = new ScriptStep
                {
                    Text = stepObj.GetString("text", ""),
                    Command = stepObj.GetString("command", ""),
                    AutoRun = stepObj.GetBool("autoRun", false),
                    Delay = stepObj.GetInt("delay", 0)
                };
            }

            return result;
        }

        public static void SaveJson(string path, string title, ScriptStep[] steps)
        {
            var sb = new StringBuilder();
            sb.AppendLine("{");
            sb.AppendLine("  \"title\": " + EscapeJsonString(title) + ",");
            sb.AppendLine("  \"steps\": [");
            for (int i = 0; i < steps.Length; i++)
            {
                var s = steps[i];
                sb.Append("    { \"text\": " + EscapeJsonString(s.Text));
                sb.Append(", \"command\": " + EscapeJsonString(s.Command));
                sb.Append(", \"autoRun\": " + (s.AutoRun ? "true" : "false"));
                sb.Append(", \"delay\": " + s.Delay.ToString());
                sb.Append(" }");
                if (i < steps.Length - 1)
                    sb.Append(",");
                sb.AppendLine();
            }
            sb.AppendLine("  ]");
            sb.AppendLine("}");

            File.WriteAllText(path, sb.ToString(), Encoding.UTF8);
        }

        public static string ExpandVariables(string command, int stepIndex, string title, int stepCount)
        {
            if (string.IsNullOrEmpty(command))
                return command;

            return command
                .Replace("{step}", (stepIndex + 1).ToString())
                .Replace("{title}", title)
                .Replace("{stepCount}", stepCount.ToString());
        }

        private static string EscapeJsonString(string s)
        {
            if (s == null) return "\"\"";
            sb.Length = 0;
            sb.Append('"');
            foreach (char c in s)
            {
                switch (c)
                {
                    case '"': sb.Append("\\\""); break;
                    case '\\': sb.Append("\\\\"); break;
                    case '\n': sb.Append("\\n"); break;
                    case '\r': sb.Append("\\r"); break;
                    case '\t': sb.Append("\\t"); break;
                    default: sb.Append(c); break;
                }
            }
            sb.Append('"');
            return sb.ToString();
        }

        private static readonly StringBuilder sb = new StringBuilder();
    }

    public class ScriptLoadResult
    {
        public string Title;
        public ScriptStep[] Steps;
    }

    #region Minimal JSON Reader

    internal class JsonReader
    {
        private readonly string _json;
        private int _pos;

        public JsonReader(string json) { _json = json; _pos = 0; }

        public JsonObject ParseObject()
        {
            SkipWhitespace();
            Expect('{');
            SkipWhitespace();

            var obj = new JsonObject();
            while (_pos < _json.Length && _json[_pos] != '}')
            {
                SkipWhitespace();
                if (_json[_pos] == '}')
                    break;
                string key = ReadString();
                SkipWhitespace();
                Expect(':');
                SkipWhitespace();
                object val = ReadValue();
                obj.Set(key, val);
                SkipWhitespace();
                if (_pos < _json.Length && _json[_pos] == ',')
                    _pos++;
            }
            Expect('}');
            return obj;
        }

        public JsonArray ParseArray()
        {
            SkipWhitespace();
            Expect('[');
            SkipWhitespace();

            var arr = new JsonArray();
            while (_pos < _json.Length && _json[_pos] != ']')
            {
                SkipWhitespace();
                if (_json[_pos] == ']')
                    break;
                arr.Add(ReadValue());
                SkipWhitespace();
                if (_pos < _json.Length && _json[_pos] == ',')
                    _pos++;
            }
            Expect(']');
            return arr;
        }

        private object ReadValue()
        {
            SkipWhitespace();
            if (_pos >= _json.Length) return null;
            char c = _json[_pos];
            if (c == '"') return ReadString();
            if (c == '{') return ParseObject();
            if (c == '[') return ParseArray();
            if (c == 't') { _pos += 4; return true; }
            if (c == 'f') { _pos += 5; return false; }
            if (c == 'n') { _pos += 4; return null; }
            if (c == '-' || (c >= '0' && c <= '9')) return ReadNumber();
            return null;
        }

        private string ReadString()
        {
            Expect('"');
            var sb = new StringBuilder();
            while (_pos < _json.Length)
            {
                char c = _json[_pos++];
                if (c == '"') return sb.ToString();
                if (c == '\\')
                {
                    if (_pos >= _json.Length) break;
                    char e = _json[_pos++];
                    switch (e)
                    {
                        case '"': sb.Append('"'); break;
                        case '\\': sb.Append('\\'); break;
                        case 'n': sb.Append('\n'); break;
                        case 'r': sb.Append('\r'); break;
                        case 't': sb.Append('\t'); break;
                        default: sb.Append(e); break;
                    }
                }
                else
                    sb.Append(c);
            }
            return sb.ToString();
        }

        private object ReadNumber()
        {
            int start = _pos;
            if (_pos < _json.Length && _json[_pos] == '-') _pos++;
            while (_pos < _json.Length && _json[_pos] >= '0' && _json[_pos] <= '9') _pos++;
            if (_pos < _json.Length && _json[_pos] == '.')
            {
                _pos++;
                while (_pos < _json.Length && _json[_pos] >= '0' && _json[_pos] <= '9') _pos++;
                double d;
                if (double.TryParse(_json.Substring(start, _pos - start),
                    System.Globalization.NumberStyles.Float,
                    System.Globalization.CultureInfo.InvariantCulture, out d))
                    return d;
                return 0.0;
            }
            int n;
            if (int.TryParse(_json.Substring(start, _pos - start), out n))
                return n;
            return 0;
        }

        private void SkipWhitespace()
        {
            while (_pos < _json.Length && char.IsWhiteSpace(_json[_pos]))
                _pos++;
        }

        private void Expect(char c)
        {
            if (_pos < _json.Length && _json[_pos] == c)
                _pos++;
        }
    }

    internal class JsonObject
    {
        private readonly Dictionary<string, object> _data = new Dictionary<string, object>();

        public void Set(string key, object val) { _data[key] = val; }

        public string GetString(string key, string defaultVal = "")
        {
            object val;
            if (_data.TryGetValue(key, out val) && val is string)
                return (string)val;
            return defaultVal;
        }

        public bool GetBool(string key, bool defaultVal = false)
        {
            object val;
            if (_data.TryGetValue(key, out val) && val is bool)
                return (bool)val;
            return defaultVal;
        }

        public int GetInt(string key, int defaultVal = 0)
        {
            object val;
            if (_data.TryGetValue(key, out val))
            {
                if (val is int) return (int)val;
                if (val is double) return (int)(double)val;
            }
            return defaultVal;
        }

        public JsonArray GetArray(string key)
        {
            object val;
            if (_data.TryGetValue(key, out val) && val is JsonArray)
                return (JsonArray)val;
            return null;
        }

        public JsonObject GetObject(string key)
        {
            object val;
            if (_data.TryGetValue(key, out val) && val is JsonObject)
                return (JsonObject)val;
            return null;
        }
    }

    internal class JsonArray
    {
        private readonly List<object> _items = new List<object>();
        public int Count { get { return _items.Count; } }
        public void Add(object item) { _items.Add(item); }

        public JsonObject GetObject(int index)
        {
            if (index >= 0 && index < _items.Count && _items[index] is JsonObject)
                return (JsonObject)_items[index];
            return null;
        }
    }

    #endregion
}