using System.Buffers.Binary;
using System.Collections;
using System.Text;

namespace CampusNet.Protocol;

/// <summary>
/// Photon GpBinary 1.8 - what the Photon Voice / newer client libraries speak (the PUN connections
/// use 1.6). Compact: counts are varints, ints are zig-zag varints, type codes are numeric.
/// Enough of it to run the name-server hop for the voice client and to hand it addresses.
/// </summary>
public static class GpBinary18
{
    // GpType
    private const byte TUnknown = 0, TBoolean = 2, TByte = 3, TShort = 4, TFloat = 5, TDouble = 6, TString = 7, TNull = 8,
        TCompressedInt = 9, TCompressedLong = 10, TInt1 = 11, TInt1_ = 12, TInt2 = 13, TInt2_ = 14, TL1 = 15, TL1_ = 16,
        TL2 = 17, TL2_ = 18, TCustom = 19, TDictionary = 20, THashtable = 21, TObjectArray = 23, TOperationRequest = 24,
        TOperationResponse = 25, TEventData = 26, TBooleanFalse = 27, TBooleanTrue = 28, TShortZero = 29, TIntZero = 30,
        TLongZero = 31, TFloatZero = 32, TDoubleZero = 33, TByteZero = 34, TArray = 64, TByteArray = 67, TCustomSlim = 128;

    public ref struct Reader
    {
        private readonly ReadOnlySpan<byte> _b; public int Pos;
        public Reader(ReadOnlySpan<byte> b, int pos = 0) { _b = b; Pos = pos; }
        public byte U8() => _b[Pos++];
        public uint VarUInt() { uint v = 0; int shift = 0; while (true) { byte b = U8(); v |= (uint)(b & 0x7F) << shift; if ((b & 0x80) == 0) return v; shift += 7; } }
        public ulong VarULong() { ulong v = 0; int shift = 0; while (true) { byte b = U8(); v |= (ulong)(b & 0x7F) << shift; if ((b & 0x80) == 0) return v; shift += 7; } }
        public int ZigInt() { uint u = VarUInt(); return (int)(u >> 1) ^ -(int)(u & 1); }
        public long ZigLong() { ulong u = VarULong(); return (long)(u >> 1) ^ -(long)(u & 1); }
        public short I16() { var v = BinaryPrimitives.ReadInt16BigEndian(_b.Slice(Pos)); Pos += 2; return v; }
        public float F32() { var v = BinaryPrimitives.ReadSingleBigEndian(_b.Slice(Pos)); Pos += 4; return v; }
        public double F64() { var v = BinaryPrimitives.ReadDoubleBigEndian(_b.Slice(Pos)); Pos += 8; return v; }
        public byte[] Bytes(int n) { var v = _b.Slice(Pos, n).ToArray(); Pos += n; return v; }
        public string Str() { int n = (int)VarUInt(); var s = Encoding.UTF8.GetString(_b.Slice(Pos, n)); Pos += n; return s; }

        public object? Value() => Value(U8());
        public object? Value(byte t)
        {
            switch (t)
            {
                case TNull: return null;
                case TBoolean: return U8() != 0;
                case TBooleanFalse: return false;
                case TBooleanTrue: return true;
                case TByte: return U8();
                case TByteZero: return (byte)0;
                case TShort: return I16();
                case TShortZero: return (short)0;
                case TFloat: return F32();
                case TFloatZero: return 0f;
                case TDouble: return F64();
                case TDoubleZero: return 0d;
                case TString: return Str();
                case TCompressedInt: return ZigInt();
                case TIntZero: return 0;
                case TInt1: return (int)U8();
                case TInt1_: return -(int)U8();
                case TInt2: return (int)(ushort)I16();
                case TInt2_: return -(int)(ushort)I16();
                case TCompressedLong: return ZigLong();
                case TLongZero: return 0L;
                case TL1: return (long)U8();
                case TL1_: return -(long)U8();
                case TL2: return (long)(ushort)I16();
                case TL2_: return -(long)(ushort)I16();
                case TByteArray: { int n = (int)VarUInt(); return Bytes(n); }
                case THashtable:
                {
                    int n = (int)VarUInt(); var h = new Hashtable(n);
                    for (int i = 0; i < n; i++) { var k = Value(); var v = Value(); if (k != null) h[k] = v; }
                    return h;
                }
                case TDictionary:
                {
                    byte kt = U8(), vt = U8(); int n = (int)VarUInt();
                    var d = new TypedDictionary { KeyType = kt, ValueType = vt };
                    for (int i = 0; i < n; i++) { var k = kt == TUnknown ? Value() : Value(kt); var v = vt == TUnknown ? Value() : Value(vt); d.Entries.Add(new(k, v)); }
                    return d;
                }
                case TObjectArray: { int n = (int)VarUInt(); var a = new object?[n]; for (int i = 0; i < n; i++) a[i] = Value(); return a; }
                case TCustom: { byte code = U8(); int n = (int)VarUInt(); return new CustomValue(code, Bytes(n)); }
                default:
                    if ((t & TCustomSlim) != 0) { byte code = (byte)(t & 0x7F); int n = (int)VarUInt(); return new CustomValue(code, Bytes(n)); }
                    if ((t & TArray) != 0)
                    {
                        int n = (int)VarUInt(); byte et = (byte)(t & ~TArray);
                        if (et == TString) { var a = new string[n]; for (int i = 0; i < n; i++) a[i] = Str(); return a; }
                        if (et == TCompressedInt) { var a = new int[n]; for (int i = 0; i < n; i++) a[i] = ZigInt(); return a; }
                        var arr = new object?[n];
                        for (int i = 0; i < n; i++) arr[i] = Value(et);
                        return new TypedArray(et, arr);
                    }
                    throw new InvalidDataException($"GpBinary18: unknown type {t} at {Pos - 1}");
            }
        }

        public Dictionary<byte, object?> Params()
        {
            int n = U8(); var d = new Dictionary<byte, object?>(n);
            for (int i = 0; i < n; i++) { byte k = U8(); d[k] = Value(); }
            return d;
        }
    }

    public static GpBinary16.OperationRequest ReadOperationRequest(ReadOnlySpan<byte> body)
    {
        var r = new Reader(body);
        var op = new GpBinary16.OperationRequest { Code = r.U8() };
        op.Params = r.Params();
        return op;
    }

    public sealed class Writer
    {
        private byte[] _b = new byte[256]; public int Length;
        private void Ensure(int n) { if (Length + n > _b.Length) Array.Resize(ref _b, Math.Max(_b.Length * 2, Length + n)); }
        public void U8(byte v) { Ensure(1); _b[Length++] = v; }
        public void Raw(ReadOnlySpan<byte> s) { Ensure(s.Length); s.CopyTo(_b.AsSpan(Length)); Length += s.Length; }
        public void VarUInt(uint v) { while (v >= 0x80) { U8((byte)(v | 0x80)); v >>= 7; } U8((byte)v); }
        public void I16(short v) { Ensure(2); BinaryPrimitives.WriteInt16BigEndian(_b.AsSpan(Length), v); Length += 2; }
        public void Str(string s) { var n = Encoding.UTF8.GetByteCount(s); VarUInt((uint)n); Ensure(n); Encoding.UTF8.GetBytes(s, _b.AsSpan(Length)); Length += n; }
        public byte[] ToArray() => _b.AsSpan(0, Length).ToArray();

        public void Value(object? v)
        {
            switch (v)
            {
                case null: U8(TNull); break;
                case bool o: U8(o ? TBooleanTrue : TBooleanFalse); break;
                case byte b: if (b == 0) U8(TByteZero); else { U8(TByte); U8(b); } break;
                case short k: if (k == 0) U8(TShortZero); else { U8(TShort); I16(k); } break;
                case int i:
                    if (i == 0) U8(TIntZero);
                    else { U8(TCompressedInt); uint z = (uint)((i << 1) ^ (i >> 31)); VarUInt(z); }
                    break;
                case long l:
                    if (l == 0) U8(TLongZero);
                    else { U8(TCompressedLong); ulong z = (ulong)((l << 1) ^ (l >> 63)); while (z >= 0x80) { U8((byte)(z | 0x80)); z >>= 7; } U8((byte)z); }
                    break;
                case float f: if (f == 0) U8(TFloatZero); else { U8(TFloat); Ensure(4); BinaryPrimitives.WriteSingleBigEndian(_b.AsSpan(Length), f); Length += 4; } break;
                case double d: if (d == 0) U8(TDoubleZero); else { U8(TDouble); Ensure(8); BinaryPrimitives.WriteDoubleBigEndian(_b.AsSpan(Length), d); Length += 8; } break;
                case string s: U8(TString); Str(s); break;
                case byte[] x: U8(TByteArray); VarUInt((uint)x.Length); Raw(x); break;
                case string[] a: U8(TArray | TString); VarUInt((uint)a.Length); foreach (var e in a) Str(e); break;
                case int[] n: U8(TArray | TCompressedInt); VarUInt((uint)n.Length); foreach (var e in n) { uint z = (uint)((e << 1) ^ (e >> 31)); VarUInt(z); } break;
                case Hashtable h: U8(THashtable); VarUInt((uint)h.Count); foreach (DictionaryEntry e in h) { Value(e.Key); Value(e.Value); } break;
                case object?[] z: U8(TObjectArray); VarUInt((uint)z.Length); foreach (var e in z) Value(e); break;
                case CustomValue c: U8(TCustom); U8(c.Code); VarUInt((uint)c.Data.Length); Raw(c.Data); break;
                default: throw new NotSupportedException($"GpBinary18: cannot serialize {v.GetType()}");
            }
        }

        public void Params(IReadOnlyDictionary<byte, object?> p)
        {
            U8((byte)p.Count);
            foreach (var e in p) { U8(e.Key); Value(e.Value); }
        }
    }

    public static byte[] OperationResponseMessage(byte opCode, short returnCode, string? debug, IReadOnlyDictionary<byte, object?> p, bool internalOp = false)
    {
        var w = new Writer();
        w.U8(GpBinary16.Magic); w.U8(internalOp ? GpBinary16.MsgInternalOperationResponse : GpBinary16.MsgOperationResponse);
        w.U8(opCode); w.I16(returnCode); w.Value(debug); w.Params(p);
        return w.ToArray();
    }

    public static byte[] EventMessage(byte eventCode, IReadOnlyDictionary<byte, object?> p)
    {
        var w = new Writer();
        w.U8(GpBinary16.Magic); w.U8(GpBinary16.MsgEvent);
        w.U8(eventCode); w.Params(p);
        return w.ToArray();
    }
}