using Implab.Components;
using Implab.Diagnostics;
using Implab.Parallels;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Implab.Fx {
    public class StaApartment : RunnableComponent {
        readonly Thread m_worker;
        SynchronizationContext m_syncContext;
        SyncContextPromise m_enterPromise;

        readonly Promise m_threadStarted;
        readonly Promise m_threadTerminated;

        public StaApartment() : base(true) {
            m_threadStarted = new Promise();
            m_threadTerminated = new Promise();

            m_worker = new Thread(WorkerEntry);
            m_worker.SetApartmentState(ApartmentState.STA);
            m_worker.IsBackground = true;
            m_worker.Name = "STA managed aparment";
        }

        public SynchronizationContext SyncContext {
            get {
                if (m_syncContext == null)
                    throw new InvalidOperationException();
                return m_syncContext;
            }
        }

        /// <summary>
        /// Returns the promise which will dispatch all handlers inside the apartment using it's <see cref="SynchronizationContext"/>
        /// </summary>
        /// <remarks>
        /// Current implementation is optimized and will lost aync operation stack
        /// </remarks>
        /// <returns>The promise</returns>
        public IPromise Enter() {
            if (m_enterPromise == null)
                throw new InvalidOperationException();
            return m_enterPromise;
        }

        public IPromise Invoke(Action<ICancellationToken> action) {
            Safe.ArgumentNotNull(action, "action");

            if (m_syncContext == null)
                throw new InvalidOperationException();
            var p = new Promise();
            var lop = TraceContext.Instance.CurrentOperation;

            m_syncContext.Post(x => {
                TraceContext.Instance.EnterLogicalOperation(lop, false);
                try {
                    if (p.CancelOperationIfRequested())
                        return;

                    action(p);
                    p.Resolve();
                } catch (Exception e) {
                    p.Reject(e);
                } finally {
                    TraceContext.Instance.Leave();
                }
            }, null);

            return p;
        }

        public IPromise<T> Invoke<T>(Func<ICancellationToken, T> action) {
            Safe.ArgumentNotNull(action, "action");

            if (m_syncContext == null)
                throw new InvalidOperationException();
            var p = new Promise<T>();
            var lop = TraceContext.Instance.CurrentOperation;

            m_syncContext.Post(x => {
                TraceContext.Instance.EnterLogicalOperation(lop, false);
                try {
                    if (p.CancelOperationIfRequested())
                        return;
                    p.Resolve(action(p));
                } catch (Exception e) {
                    p.Reject(e);
                } finally {
                    TraceContext.Instance.Leave();
                }
            }, null);

            return p;
        }

        public IPromise Invoke(Action action) {
            Safe.ArgumentNotNull(action, "action");

            if (m_syncContext == null)
                throw new InvalidOperationException();
            var p = new Promise();
            var lop = TraceContext.Instance.CurrentOperation;

            m_syncContext.Post(x => {
                TraceContext.Instance.EnterLogicalOperation(lop, false);
                try {
                    if (p.CancelOperationIfRequested())
                        return;
                    action();
                    p.Resolve();
                } catch (Exception e) {
                    p.Reject(e);
                } finally {
                    TraceContext.Instance.Leave();
                }
            }, null);

            return p;
        }

        public IPromise<T> Invoke<T>(Func<T> action) {
            Safe.ArgumentNotNull(action, "action");

            if (m_syncContext == null)
                throw new InvalidOperationException();
            var p = new Promise<T>();
            var lop = TraceContext.Instance.CurrentOperation;

            m_syncContext.Post(x => {
                TraceContext.Instance.EnterLogicalOperation(lop, false);
                try {
                    if (p.CancelOperationIfRequested())
                        return;
                    p.Resolve(action());
                } catch (Exception e) {
                    p.Reject(e);
                } finally {
                    TraceContext.Instance.Leave();
                }
            }, null);

            return p;
        }


        /// <summary>
        /// Starts the apartment thread
        /// </summary>
        /// <returns>Promise which will be fullfiled when the syncronization
        /// context will be ready to accept tasks.</returns>
        protected override IPromise OnStart() {
            m_worker.Start();
            return m_threadStarted;
        }

        /// <summary>
        /// Posts quit message to the message loop of the apartment
        /// </summary>
        /// <returns>Promise</returns>
        protected override IPromise OnStop() {
            m_syncContext.Post(x => Application.ExitThread(), null);
            return m_threadTerminated;
        }

        void WorkerEntry() {
            m_syncContext = new WindowsFormsSynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(m_syncContext);
            m_enterPromise = new SyncContextPromise(m_syncContext);
            m_threadStarted.Resolve();
            m_enterPromise.Resolve();

            Application.OleRequired();
            Application.Run();

            try {
                OnShutdown();
                m_threadTerminated.Resolve();
            } catch(Exception err) {
                m_threadTerminated.Reject(err);
            }
        }

        /// <summary>
        /// Called from the STA apartment after the message loop is terminated, override this
        /// method to handle apartment cleanup.
        /// </summary>
        protected virtual void OnShutdown() {
        }

        protected override void Dispose(bool disposing) {
            if (disposing) {
                if (!m_threadTerminated.IsFulfilled)
                    m_syncContext.Post(x => Application.ExitThread(), null);
            }
            base.Dispose(disposing);
        }
    }
}