package com.adobe.cairngorm.logging
{
    import flash.events.ErrorEvent;
    import flash.events.EventDispatcher;

    import mx.core.Application;
    import mx.core.UIComponentGlobals;
    import mx.events.DynamicEvent;
    import mx.events.FlexEvent;
    import mx.logging.ILogger;
    import mx.logging.Log;
    import mx.managers.ISystemManager;

    [Event(name="error",type="flash.events.ErrorEvent")]
    public class AsyncErrorLogger extends EventDispatcher
    {
        //------------------------------------------------------------------------
        //
        //  Constants
        //
        //------------------------------------------------------------------------
        private static const CALL_LATER_ERROR:String = "callLaterError";

        private static const LOG:ILogger = Log.getLogger("com.adobe.cairngorm.AsyncErrorLogger");


        //------------------------------------------------------------------------
        //
        //  Properties
        //
        //------------------------------------------------------------------------

        //-------------------------------
        //  systemManager
        //-------------------------------
        private var systemManager:ISystemManager;

        //-------------------------------
        //  logStackTrace
        //-------------------------------

        public var logStackTrace:Boolean = true;

        //-------------------------------
        //  redispatchError
        //-------------------------------
        public var redispatchError:Boolean = false;

        //-------------------------------
        //  enabled
        //-------------------------------

        [Bindable]
        public function get enabled():Boolean
        {
            return UIComponentGlobals.catchCallLaterExceptions;
        }

        public function set enabled(value:Boolean):void
        {
            UIComponentGlobals.catchCallLaterExceptions = value;
        }


        //------------------------------------------------------------------------
        //
        //  Constructor
        //
        //------------------------------------------------------------------------

        public function AsyncErrorLogger(systemManager:ISystemManager = null)
        {
            enabled = true;

            init(systemManager);
        }


        //------------------------------------------------------------------------
        //
        //  Private Methods
        //
        //------------------------------------------------------------------------

        private function init(systemManager:ISystemManager):void
        {
            if (systemManager)
            {
                initializeListener(systemManager);
            }
            else
            {
                var application:Object = Application.application;

                if (!application.initialized)
                {
                    application.addEventListener(FlexEvent.CREATION_COMPLETE, creationCompleteHandler);
                }
                else
                {
                    initializeListener(application.systemManager);
                }
            }
        }

        private function creationCompleteHandler(event:Event):void
        {
            var application:Object = Application.application;
            application.removeEventListener(FlexEvent.INIT_COMPLETE, creationCompleteHandler);

            initializeListener(application.systemManager);
        }

        private function initializeListener(systemManager:ISystemManager):void
        {
            this.systemManager = systemManager;

            if (this.systemManager)
            {
                LOG.debug("AsynErrorLogger initialized.");
                this.systemManager.addEventListener(CALL_LATER_ERROR, errorHandler);
            }
        }

        private function errorHandler(event:DynamicEvent):void
        {
            var error:Error = event.error as Error;

            LOG.error("{0}", error.message);

            if (logStackTrace)
            {
                LOG.error(error.getStackTrace());
            }

            if (redispatchError)
            {
                var errorEvent:ErrorEvent = new ErrorEvent(ErrorEvent.ERROR, false, false, error.getStackTrace(), error.errorID);
                dispatchEvent(errorEvent);
            }
        }
    }
}