using System;
using Implab.Parsing;

namespace Implab.Components {
    public class RunnableComponent : Disposable, IRunnable, IInitializable {
        class Automaton : DFAutomaton<ExecutionState> {
            static readonly EDFADefinition<ExecutionState> _dfa;

            static Automaton() {

                var token = Token
                    .New(ExecutionState.Uninitialized).Optional() // we can skip uninitialized state
                    .Cat(
                        Token.New(ExecutionState.Ready) // uninitialized -> initial
                        .Cat(
                            Token.New(ExecutionState.Starting) // initial -> starting
                            .Cat(
                                Token.New(ExecutionState.Running) // running -> {stopping -> stopped | failed }
                                .Cat(
                                    Token.New(ExecutionState.Stopping) // running -> stopping
                                    .Cat(
                                        Token.New(ExecutionState.Stopped) // stopping -> stopped
                                        .Or(Token.New(ExecutionState.Failed)) // stopping -> failed
                                    )
                                    .Or(Token.New(ExecutionState.Failed)) // running -> failed
                                )
                                .Or(Token.New(ExecutionState.Failed)) // starting -> failed
                            ).EClosure()
                        )
                        .Or(Token.New(ExecutionState.Failed)) // uninitialized->failed
                        .Cat(Token.New(ExecutionState.Disposed).Tag(0)) // ... -> disposed
                    );
                
                var builder = new DFABuilder();
                token.Accept(builder);

                var _dfa = new EDFADefinition<ExecutionState>(EnumAlphabet<ExecutionState>.FullAlphabet);
                builder.BuildDFA(_dfa); // don't optimize dfa to avoid remapping of the alphabet

            }

            public Automaton() : base(_dfa.States, INITIAL_STATE, ExecutionState.Reserved) {
            }

            public void MoveTo(ExecutionState state) {
                
                if (!CanMove((int)state))
                    throw new InvalidOperationException(String.Format("Illegal state transition from {0} to {1}", Current, state));
                Move((int)state);
                m_context.info = state;
            }

            public ExecutionState Current {
                get { 
                    return (ExecutionState)m_context.info;
                }
            }
        }

        readonly Automaton m_automaton = new Automaton();
        IPromise m_pending;
        Exception m_lastError;

        protected RunnableComponent(bool initialized) {
            if (initialized)
                m_automaton.MoveTo(ExecutionState.Ready);
            else
                m_automaton.MoveTo(ExecutionState.Uninitialized);
        }

        #region IInitializable implementation

        public void Init() {
            
        }

        #endregion

        #region IRunnable implementation

        public IPromise Start() {
            return Safe.InvokePromise(() => {
                Promise promise;
                lock (m_automaton) {
                    if (m_automaton.Current == ExecutionState.Starting)
                        return m_pending;
                    m_automaton.MoveTo(ExecutionState.Starting);
                    m_pending = promise = new Promise();
                }

                var start = Safe.InvokePromise(OnStart);
                promise.On(null, null, start.Cancel);
                start.On(promise.Resolve, promise.Reject, promise.CancelOperation);

                return promise.Then(() => {
                    lock(m_automaton) {
                        m_automaton.MoveTo(ExecutionState.Running);
                        m_pending = null;
                    }

                    Run();
                }, err => {
                    if (BeginTransition(RUNNING_REQUIRE)) {
                        m_lastError = err;
                        CompleteTransition(FAILED_STATE);
                        throw new PromiseTransientException(err);
                    }
                    throw new OperationCanceledException();
                }, reason => {
                    throw new OperationCanceledException("The operation was cancelled", reason);
                });
            });
        }

        protected virtual IPromise OnStart() {
            return Promise.SUCCESS;
        }

        protected virtual void Run() {
        }

        public IPromise Stop() {
            throw new NotImplementedException();
        }

        public ExecutionState State {
            get {
                throw new NotImplementedException();
            }
        }

        public Exception LastError {
            get {
                throw new NotImplementedException();
            }
        }

        #endregion
    }
}