using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Normal.Realtime.Serialization;

public partial class RealtimeTransformModel {
    [RealtimeProperty(1, false)] private Vector3    _position;
    [RealtimeProperty(2, false)] private Quaternion _rotation;
    [RealtimeProperty(3, false)] private Vector3    _scale = Vector3.one;
    [RealtimeProperty(4, false)] private Vector3    _velocity;
    [RealtimeProperty(5, false)] private Vector3    _angularVelocity;
    //[RealtimeProperty(6, false)] private Vector3    _scaleVelocity;

    [Flags]
    private enum Flags : uint {
        Default           = 0,
        ShouldExtrapolate = 1 << 0,
        UseGravity        = 1 << 1,
        IsKinematic       = 1 << 2,
    }
    [RealtimeProperty(7, true)] private uint _physicsState = 0;

    [RealtimeProperty(8, false)] private double _timestamp;

    // Used to signal whether RealtimeTransform should set defaults in SetModel
    public bool freshModel { get; private set; }

    // TODO: Move this to the common model base class once it's written.
    public  delegate void RealtimeTransformModelEvent(RealtimeTransformModel model);
    public  event RealtimeTransformModelEvent willWrite;
    public  event RealtimeTransformModelEvent didRead;
    private bool _didDispatchWillWriteEvent = false;
}

public partial class RealtimeTransformModel : IModel {
    // Properties
    public UnityEngine.Vector3 position {
        get { return _position; }
        set { if (!shouldWritePosition) return; if (value == _position) return; _positionShouldWrite = true; _position = value; }
    }
    public UnityEngine.Quaternion rotation {
        get { return _rotation; }
        set { if (!shouldWriteRotation) return; if (value == _rotation) return; _rotationShouldWrite = true; _rotation = value; }
    }
    public UnityEngine.Vector3 scale {
        get { return _scale; }
        set { if (!shouldWriteScale) return; if (value == _scale) return; _scaleShouldWrite = true; _scale = value; }
    }
    public UnityEngine.Vector3 velocity {
        get { return _velocity; }
        set { if (!shouldWriteVelocityMetadata) return; if (value == _velocity) return; _velocityShouldWrite = true; _velocity = value; }
    }
    public UnityEngine.Vector3 angularVelocity {
        get { return _angularVelocity; }
        set { if (!shouldWriteVelocityMetadata) return; if (value == _angularVelocity) return; _angularVelocityShouldWrite = true; _angularVelocity = value; }
    }
    //public UnityEngine.Vector3 scaleVelocity {
    //    get { return _scaleVelocity; }
    //    set { if (value == _scaleVelocity) return; _scaleVelocityShouldWrite = true; _scaleVelocity = value; }
    //}
    public double timestamp {
        get { return _timestamp; }
        set { if (value == _timestamp) return; _timestampShouldWrite = true; _timestamp = value; }
    }

    private uint physicsState {
        get { return _cache.LookForValueInCache(_physicsState, entry => entry.physicsStateSet, entry => entry.physicsState); }
        set { _cache.UpdateLocalCache(entry => { entry.physicsStateSet = true; entry.physicsState = value; return entry; }); }
    }

    public bool shouldExtrapolate { get { return (physicsState & (uint)Flags.ShouldExtrapolate) != 0; } set { if (value == shouldExtrapolate) return; if (value) physicsState |= (uint)Flags.ShouldExtrapolate; else physicsState &= ~((uint)Flags.ShouldExtrapolate); } }
    public bool useGravity        { get { return (physicsState & (uint)Flags.UseGravity)        != 0; } set { if (value == useGravity)        return; if (value) physicsState |= (uint)Flags.UseGravity;        else physicsState &= ~((uint)Flags.UseGravity);        } }
    public bool isKinematic       { get { return (physicsState & (uint)Flags.IsKinematic)       != 0; } set { if (value == isKinematic)       return; if (value) physicsState |= (uint)Flags.IsKinematic;       else physicsState &= ~((uint)Flags.IsKinematic);       } }


    // Previous snapshot
    public Vector3    previousPosition  { get; private set; }
    public Quaternion previousRotation  { get; private set; }
    public double     previousTimestamp { get; private set; }


    // Will this model write
    public bool ModelPoseChangesToSend() {
        return _positionShouldWrite || _rotationShouldWrite || _scaleShouldWrite;
    }


    public bool shouldWritePosition = false;
    public bool shouldWriteRotation = false;
    public bool shouldWriteScale    = false;
    public bool shouldWriteVelocityMetadata = false;

    // Ownership
    public int ownerID { get { return _metaModel.ownerID; } }
    
    public void RequestOwnership(int clientIndex) {
        _metaModel.ownerID = clientIndex;
    }
    
    public void ClearOwnership() {
        _metaModel.ownerID = -1;
    }
    
    // Meta model
    private MetaModel _metaModel;
    
    private bool _positionShouldWrite;
    private bool _rotationShouldWrite;
    private bool _scaleShouldWrite;
    private bool _velocityShouldWrite;
    private bool _angularVelocityShouldWrite;
    //private bool _scaleVelocityShouldWrite;
    private bool _timestampShouldWrite;

    // Change Cache
    private struct LocalCacheEntry {
        public bool physicsStateSet;
        public uint physicsState;
    }
    private LocalChangeCache<LocalCacheEntry> _cache;

    public RealtimeTransformModel() {
        freshModel = true;
        
        _metaModel = new MetaModel();

        _cache = new LocalChangeCache<LocalCacheEntry>();
    }
    
    // Serialization
    enum PropertyID {
        Position = 1,
        Rotation = 2,
        Scale = 3,
        Velocity = 4,
        AngularVelocity = 5,
        ScaleVelocity = 6,
        PhysicsState = 7,
        Timestamp = 8,
    }

    public int WriteLength(StreamContext context) {
        // Dispatch will write event.
        if (!_didDispatchWillWriteEvent) {
            // Mark dispatched first in case willWrite triggers a WriteLength() call.
            _didDispatchWillWriteEvent = true;

            if (willWrite != null) {
                try {
                    willWrite(this);
                } catch (Exception exception) {
                    Debug.LogException(exception);
                }
            }
        }

        int length = 0;
        
        if (context.fullModel) {
            // Flatten cache
            _physicsState = physicsState;
            _cache.Clear();

            // Meta model
            length += WriteStream.WriteModelLength(0, _metaModel, context);

            // Write all properties
            if (shouldWritePosition)
                length += WriteStream.WriteBytesLength((uint)PropertyID.Position,        WriteStream.Vector3ToBytesLength());
            if (shouldWriteRotation)
                length += WriteStream.WriteBytesLength((uint)PropertyID.Rotation,        WriteStream.QuaternionToBytesLength());
            if (shouldWriteScale)
                length += WriteStream.WriteBytesLength((uint)PropertyID.Scale,           WriteStream.Vector3ToBytesLength());

            if (shouldWriteVelocityMetadata) {
                length += WriteStream.WriteBytesLength((uint)PropertyID.Velocity,        WriteStream.Vector3ToBytesLength());
                length += WriteStream.WriteBytesLength((uint)PropertyID.AngularVelocity, WriteStream.Vector3ToBytesLength());
                //length += WriteStream.WriteBytesLength((uint)PropertyID.ScaleVelocity,   WriteStream.Vector3ToBytesLength());
            }
            length += WriteStream.WriteVarint32Length((uint)PropertyID.PhysicsState, _physicsState);

            length += WriteStream.WriteBytesLength((uint)PropertyID.Timestamp, sizeof(double));
        } else {
            // Meta model
            length += WriteStream.WriteModelLength(0, _metaModel, context);
            
            // Unreliable properties
            if (context.unreliableChannel) {
                if (_positionShouldWrite) {
                    length += WriteStream.WriteBytesLength((uint)PropertyID.Position, WriteStream.Vector3ToBytesLength());
                }
                if (_rotationShouldWrite) {
                    length += WriteStream.WriteBytesLength((uint)PropertyID.Rotation, WriteStream.QuaternionToBytesLength());
                }
                if (_scaleShouldWrite) {
                    length += WriteStream.WriteBytesLength((uint)PropertyID.Scale, WriteStream.Vector3ToBytesLength());
                }
                if (_velocityShouldWrite) {
                    length += WriteStream.WriteBytesLength((uint)PropertyID.Velocity, WriteStream.Vector3ToBytesLength());
                }
                if (_angularVelocityShouldWrite) {
                    length += WriteStream.WriteBytesLength((uint)PropertyID.AngularVelocity, WriteStream.Vector3ToBytesLength());
                }
                ///if (_scaleVelocityShouldWrite) {
                //    length += WriteStream.WriteBytesLength((uint)PropertyID.ScaleVelocity, WriteStream.Vector3ToBytesLength());
                //}
                if (_timestampShouldWrite) {
                    length += WriteStream.WriteBytesLength((uint)PropertyID.Timestamp, sizeof(double));
                }
            } else if (context.reliableChannel) {
                LocalCacheEntry entry = _cache.localCache;
                if (entry.physicsStateSet)
                    length += WriteStream.WriteVarint32Length((uint)PropertyID.PhysicsState, entry.physicsState);
            }
        }

        // If the length is zero, a Write event will never get called.
        // TODO: Unfortunately this means that if the WriteLength is zero, the event will be dispatched multiple times in a single WriteStream.Serialize() pass.
        // If the model changes between those events, serialization will fail...
        if (length == 0)
            _didDispatchWillWriteEvent = false;
        
        return length;
    }
    
    public void Write(WriteStream stream, StreamContext context) {
        if (context.fullModel) {
            // Meta model
            stream.WriteModel(0, _metaModel, context);

            // Write all properties
            if (shouldWritePosition)
                stream.WriteBytes((uint)PropertyID.Position, WriteStream.Vector3ToBytes(_position));
            if (shouldWriteRotation)
                stream.WriteBytes((uint)PropertyID.Rotation, WriteStream.QuaternionToBytes(_rotation));
            if (shouldWriteScale)
                stream.WriteBytes((uint)PropertyID.Scale, WriteStream.Vector3ToBytes(_scale));

            if (shouldWriteVelocityMetadata) {
                stream.WriteBytes((uint)PropertyID.Velocity, WriteStream.Vector3ToBytes(_velocity));
                stream.WriteBytes((uint)PropertyID.AngularVelocity, WriteStream.Vector3ToBytes(_angularVelocity));
                //stream.WriteBytes((uint)PropertyID.ScaleVelocity, WriteStream.Vector3ToBytes(_scaleVelocity));
            }
            stream.WriteVarint32((uint)PropertyID.PhysicsState, _physicsState);

            stream.WriteBytes((uint)PropertyID.Timestamp, BitConverter.GetBytes(_timestamp));
        } else {
            // Meta model
            stream.WriteModel(0, _metaModel, context);
            
            // Unreliable properties
            if (context.unreliableChannel) {
                if (_positionShouldWrite) {
                    stream.WriteBytes((uint)PropertyID.Position, WriteStream.Vector3ToBytes(_position));
                    _positionShouldWrite = false;
                }
                if (_rotationShouldWrite) {
                    stream.WriteBytes((uint)PropertyID.Rotation, WriteStream.QuaternionToBytes(_rotation));
                    _rotationShouldWrite = false;
                }
                if (_scaleShouldWrite) {
                    stream.WriteBytes((uint)PropertyID.Scale, WriteStream.Vector3ToBytes(_scale));
                    _scaleShouldWrite = false;
                }
                if (_velocityShouldWrite) {
                    stream.WriteBytes((uint)PropertyID.Velocity, WriteStream.Vector3ToBytes(_velocity));
                    _velocityShouldWrite = false;
                }
                if (_angularVelocityShouldWrite) {
                    stream.WriteBytes((uint)PropertyID.AngularVelocity, WriteStream.Vector3ToBytes(_angularVelocity));
                    _angularVelocityShouldWrite = false;
                }
                //if (_scaleVelocityShouldWrite) {
                //    stream.WriteBytes((uint)PropertyID.ScaleVelocity, WriteStream.Vector3ToBytes(_scaleVelocity));
                //    _scaleVelocityShouldWrite = false;
                //}
                if (_timestampShouldWrite) {
                    stream.WriteBytes((uint)PropertyID.Timestamp, BitConverter.GetBytes(_timestamp));
                    _timestampShouldWrite = false;
                }
            } else if (context.reliableChannel) {
                // If we're going to send an update. Push the cache to inflight.
                LocalCacheEntry entry = _cache.localCache;
                if (entry.physicsStateSet)
                    _cache.PushLocalCacheToInflight(context.updateID);

                if (entry.physicsStateSet)
                    stream.WriteVarint32((uint)PropertyID.PhysicsState, entry.physicsState);
            }
        }

        // Reset will write event flag.
        _didDispatchWillWriteEvent = false;
    }
    
    public void Read(ReadStream stream, StreamContext context) {
        // Used to signal whether RealtimeTransform should set defaults in SetModel
        freshModel = false;

        // Remove from in-flight
        if (context.deltaUpdatesOnly && context.reliableChannel)
            _cache.RemoveUpdateFromInflight(context.updateID);

        // Store previous snapshot (used for transform extrapolation)
        Vector3    preReadPosition = position;
        Quaternion preReadRotation = rotation;

        // Loop through each property and deserialize
        uint propertyID;
        while (stream.ReadNextPropertyID(out propertyID)) {
            switch (propertyID) {
                case 0:
                    // Meta model
                    stream.ReadModel(_metaModel, context);
                    break;
                case (uint)PropertyID.Position: {
                    _position = ReadStream.Vector3FromBytes(stream.ReadBytes());
                    _positionShouldWrite = false;
                    break;
                }
                case (uint)PropertyID.Rotation: {
                    _rotation = ReadStream.QuaternionFromBytes(stream.ReadBytes());
                    _rotationShouldWrite = false;
                    break;
                }
                case (uint)PropertyID.Scale: {
                    _scale = ReadStream.Vector3FromBytes(stream.ReadBytes());
                    _scaleShouldWrite = false;
                    break;
                }
                case (uint)PropertyID.Velocity: {
                    _velocity = ReadStream.Vector3FromBytes(stream.ReadBytes());
                    _velocityShouldWrite = false;
                    break;
                }
                case (uint)PropertyID.AngularVelocity: {
                    _angularVelocity = ReadStream.Vector3FromBytes(stream.ReadBytes());
                    _angularVelocityShouldWrite = false;
                    break;
                }
                //case (uint)PropertyID.ScaleVelocity: {
                //    _scaleVelocity = ReadStream.Vector3FromBytes(stream.ReadBytes());
                //    _scaleVelocityShouldWrite = false;
                //    break;
                //}
                case (uint)PropertyID.PhysicsState: {
                    _physicsState = stream.ReadVarint32();
                    break;
                }
                case (uint)PropertyID.Timestamp: {
                    // We got a timestamp, cache the previous snapshot's values.
                    previousPosition  = preReadPosition;
                    previousRotation  = preReadRotation;
                    previousTimestamp = timestamp;
                    
                    byte[] bytes = stream.ReadBytes();
                    _timestamp = BitConverter.ToDouble(bytes, 0);
                    break;
                }
                default:
                    stream.SkipProperty();
                    break;
            }
        }

        if (didRead != null) {
            try {
                didRead(this);
            } catch (Exception exception) {
                Debug.LogException(exception);
            }
        }
    }
}