#region Copyright
/*
* Copyright © 2014-2016 NetApp, Inc. All Rights Reserved.
*
* CONFIDENTIALITY NOTICE: THIS SOFTWARE CONTAINS CONFIDENTIAL INFORMATION OF
* NETAPP, INC. USE, DISCLOSURE OR REPRODUCTION IS PROHIBITED WITHOUT THE PRIOR
* EXPRESS WRITTEN PERMISSION OF NETAPP, INC.
*/
#endregion

#region Using Directives

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Management.Automation;
using SolidFire.Core.Objects;
using SolidFire.Core.Validation;
using SolidFire.Core;
using SolidFire.Element.Api;
#endregion

namespace SolidFire.Cluster.Get
{
    /// <summary>
    /// ListEvents returns events detected on the cluster, sorted from oldest to newest. 
    /// </summary>
    
    [Cmdlet(VerbsCommon.Get, "SFEvent", DefaultParameterSetName = "EventId")]
    public class GetSFEvent : SFCmdlet
    {
        #region Private Data

        /// <summary>
        /// 
        /// </summary>
        private Int64? startEventId;
        private Int64? endEventId;
        private Int64? maxEvents;
        #endregion

        #region Parameters

        [Parameter(Position = 0, ParameterSetName = "EventId", Mandatory = false, ValueFromPipeline = true, ValueFromPipelineByPropertyName = true, ValueFromRemainingArguments = false, HelpMessage = "Please enter a starting event ID")]
        [ValidateNotNullOrEmpty]
        [ValidatePattern(SolidFireValidations.Numeric)]
        public Int64 StartEventID
        {   set
            {
                startEventId = value;
            }
        }

        [Parameter(Position = 1, ParameterSetName = "EventId", Mandatory = false, ValueFromPipeline = true, ValueFromPipelineByPropertyName = true, ValueFromRemainingArguments = false, HelpMessage = "Please enter an ending event ID")]
        [ValidateNotNullOrEmpty]
        [ValidatePattern(SolidFireValidations.Numeric)]
        public Int64 EndEventID
        {
            set
            {
                endEventId = value;
            }
        }

        [Parameter(Position = 1, ParameterSetName = "MaxEvents", Mandatory = false, ValueFromPipeline = true, ValueFromPipelineByPropertyName = true, ValueFromRemainingArguments = false, HelpMessage = "Please enter the maximum number of events to return")]
        [ValidatePattern(SolidFireValidations.Numeric)]
        public Int64 MaxEvents
        {
            set
            {
                maxEvents = value;
            }
        }
        
        #endregion

        #region Cmdlet Overrides
        protected override void BeginProcessing()
        {
            base.BeginProcessing();
            CheckConnection();
        }
        /// <summary>
        /// 
        /// </summary>
        protected override void ProcessRecord()
        {
            base.ProcessRecord();

            var request = new ListEventsRequest();
            request.StartEventID = startEventId;
            request.EndEventID = endEventId;
            request.MaxEvents = maxEvents;

            var objsFromAPI = SendRequest<ListEventsResult>("ListEvents", request);

            foreach (var obj in objsFromAPI)
            {
                switch (ParameterSetName)
                {
                    case "EventId":
                        ProcessByID(obj);
                        break;
                    case "MaxEvents":
                    default:
                        WriteObject(ReOrderEvents(obj.Result.Events), true);
                        break;

                }
            }
        }

        private void ProcessByID(SFWrapper<ListEventsResult> objFromApi)
        {
            var matchedEvents = new List<EventInfo>();

            var containsStartId = false;
            var containsEndId = false;
            Int64 minEventIdFound = Int64.MaxValue;
            Int64 maxEventIdFound = 0;

            // Initial check to ensure the specified start and end event IDs are actually valid and to gather min and max event Id values
            foreach (var eventObj in objFromApi.Result.Events)
            {
                if (eventObj.EventID < minEventIdFound) minEventIdFound = eventObj.EventID;
                if (eventObj.EventID > maxEventIdFound) maxEventIdFound = eventObj.EventID;

                if (eventObj.EventID == startEventId)
                {
                    containsStartId = true;
                }

                if (eventObj.EventID == endEventId)
                {
                    containsEndId = true;
                }
            }

            if (!startEventId.HasValue && !endEventId.HasValue)
            {
                var reorderedEvents = ReOrderEvents(objFromApi.Result.Events);
                WriteObject(reorderedEvents, true);
                return;
            }

            // we only have an endEventId
            if (!startEventId.HasValue && endEventId.HasValue)
            {
                if (containsEndId)
                {
                    matchedEvents.AddRange(objFromApi.Result.Events.Where(sfEvent => sfEvent.EventID <= endEventId.Value));

                    // As we are adding events to matchedEvents, the top of the list will be the last event added, so we need to re-order for the list to make sense to the user
                    var reorderedList = ReOrderEvents(matchedEvents);
                    WriteObject(reorderedList, true);
                    return;
                }
            }


            // we only have a starteventid
            if (startEventId.HasValue && !endEventId.HasValue)
            {
                if (containsStartId)
                {
                    matchedEvents.AddRange(objFromApi.Result.Events.Where(sfEvent => sfEvent.EventID >= startEventId.Value));

                    // As we are adding events to matchedEvents, the top of the list will be the last event added, so we need to re-order for the list to make sense to the user
                    var reorderedList = ReOrderEvents(matchedEvents);
                    WriteObject(reorderedList, true);
                    return;
                }
            }

            if (startEventId.HasValue && endEventId.HasValue)
            {

                matchedEvents.AddRange(objFromApi.Result.Events.Where(sfEvent => sfEvent.EventID >= startEventId.Value && sfEvent.EventID <= endEventId.Value));

                // As we are adding events to matchedEvents, the top of the list will be the last event added, so we need to re-order for the list to make sense to the user
                var reorderedList = ReOrderEvents(matchedEvents);
                WriteObject(reorderedList, true);
                return;
            }
        }

        private static IOrderedEnumerable<EventInfo> ReOrderEvents(IEnumerable<EventInfo> matchedEvents)
        {
            var reorderedList = matchedEvents.OrderByDescending(e => e.EventID);
            return reorderedList;
        }

        #endregion
    }
}