/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Collections.Generic;

using Apache.NMS.ActiveMQ.Commands;
using Apache.NMS.ActiveMQ.Util;
using Apache.NMS.Util;

namespace Apache.NMS.ActiveMQ.Transactions
{
    public class RecoveryLoggerHarness : IRecoveryLogger
    {
        public delegate void HarnessedEventHandler();
        public delegate void HarnessedLogRecoveryInfoHandler(XATransactionId xid, byte[] recoveryInfo);
        public delegate void HarnessedLogRecoveredHandler(XATransactionId xid);
        public delegate void HarnessedGetRecoverablesHandler(KeyValuePair<XATransactionId, byte[]>[] recoverables);
        
        private static readonly FactoryFinder<RecoveryLoggerFactoryAttribute, IRecoveryLoggerFactory> FACTORY_FINDER =
            new FactoryFinder<RecoveryLoggerFactoryAttribute, IRecoveryLoggerFactory>();

        private IRecoveryLogger containedLogger;

        public event HarnessedEventHandler PreInitializeEvent;
        public event HarnessedEventHandler PostInitializeEvent;

        public event HarnessedLogRecoveryInfoHandler PreLogRecoveryInfoEvent;
        public event HarnessedLogRecoveryInfoHandler PostLogRecoveryInfoEvent;

        public event HarnessedLogRecoveredHandler PreLogRecoverdEvent;
        public event HarnessedLogRecoveredHandler PostLogRecoverdEvent;

        public event HarnessedGetRecoverablesHandler PreGetRecoverablesEvent;
        public event HarnessedGetRecoverablesHandler PostGetRecoverablesEvent;

        public event HarnessedEventHandler PrePurgeEvent;
        public event HarnessedEventHandler PostPurgeEvent;

        public RecoveryLoggerHarness()
        {
            this.containedLogger = new RecoveryFileLogger();
        }

        public string ResourceManagerId
        {
            get { return this.containedLogger.ResourceManagerId; }
        }

        public void Initialize(string resourceManagerId)
        {
            if(this.PreInitializeEvent != null)
            {
                this.PreInitializeEvent();
            }
            
            this.containedLogger.Initialize(resourceManagerId);

            if (this.PostInitializeEvent != null)
            {
                this.PostInitializeEvent();
            }
        }

        public void LogRecoveryInfo(XATransactionId xid, byte[] recoveryInformation)
        {
            if (recoveryInformation == null || recoveryInformation.Length == 0)
            {
                return;
            }

            if (this.PreLogRecoveryInfoEvent != null)
            {
                this.PreLogRecoveryInfoEvent(xid, recoveryInformation);
            }

            this.containedLogger.LogRecoveryInfo(xid, recoveryInformation);

            if (this.PostLogRecoveryInfoEvent != null)
            {
                this.PostLogRecoveryInfoEvent(xid, recoveryInformation);
            }
        }

        public KeyValuePair<XATransactionId, byte[]>[] GetRecoverables()
        {
            KeyValuePair<XATransactionId, byte[]>[] result = new KeyValuePair<XATransactionId, byte[]>[0];

            if (this.PreGetRecoverablesEvent != null)
            {
                this.PreGetRecoverablesEvent(result);
            }

            result = this.containedLogger.GetRecoverables();

            if (this.PostGetRecoverablesEvent != null)
            {
                this.PostGetRecoverablesEvent(result);
            }

            return result;
        }

        public void LogRecovered(XATransactionId xid)
        {
            if (this.PreLogRecoverdEvent != null)
            {
                this.PreLogRecoverdEvent(xid);
            }

            this.containedLogger.LogRecovered(xid);

            if (this.PostLogRecoverdEvent != null)
            {
                this.PostLogRecoverdEvent(xid);
            }
        }

        public void Purge()
        {
            if (this.PrePurgeEvent != null)
            {
                this.PrePurgeEvent();
            }

            this.containedLogger.Purge();

            if (this.PostPurgeEvent != null)
            {
                this.PostPurgeEvent();
            }
        }

        public string LoggerType
        {
            get { return this.containedLogger.LoggerType; }
        }

        #region Harness Methods

        public IRecoveryLogger Harnessed
        {
            get { return this.containedLogger; }    
        }

        public string HarnessedType
        {
            get { return this.containedLogger != null ? this.containedLogger.LoggerType : ""; }
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw new NMSException(String.Format("Recovery Logger name invalid: [{0}]", value));
                }

                IRecoveryLoggerFactory factory = null;

                try
                {
                    factory = NewInstance(value.ToLower());
                }
                catch (NMSException)
                {
                    throw;
                }
                catch (Exception e)
                {
                    throw NMSExceptionSupport.Create("Error creating Recovery Logger", e);
                }

                this.containedLogger = factory.Create();
            }
        }

        private static IRecoveryLoggerFactory NewInstance(string scheme)
        {
            try
            {
                Type factoryType = FindLoggerFactory(scheme);

                if (factoryType == null)
                {
                    throw new Exception("NewInstance failed to find a match for id = " + scheme);
                }

                return (IRecoveryLoggerFactory)Activator.CreateInstance(factoryType);
            }
            catch (Exception ex)
            {
                Tracer.WarnFormat("NewInstance failed to create an IRecoveryLoggerFactory with error: {1}", ex.Message);
                throw;
            }
        }

        private static Type FindLoggerFactory(string scheme)
        {
            try
            {
                return FACTORY_FINDER.FindFactoryType(scheme);
            }
            catch
            {
                throw new NMSException("Failed to find Factory for Recovery Logger type: " + scheme);
            }
        }

        public Object Clone()
        {
            return this.MemberwiseClone();
        }       

        #endregion
    }
}