using BuddyFinance.Integration.Logging;
using BuddyFinance.Integration.Models;
using BuddyFinance.Integration.Models.Enums;
using BuddyFinance.Integration.Utils;
using System;
using System.Configuration;
using System.Data.Entity.Validation;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web.Helpers;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;

namespace BuddyFinance.WebApi.Filters
{
    //TODO: Update Log entry description to be user friendly
    /// <summary>
    /// 
    /// </summary>
    public class LogAttribute : ActionFilterAttribute
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actionContext"></param>
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            var token = System.Web.HttpContext.Current.Request.Headers["X-Auth-Token"];
            int? userId = TokenManager.UserId(token);

            var action = actionContext.ActionDescriptor.ActionName;
            var contoller = actionContext.ActionDescriptor.ControllerDescriptor.ControllerName;

            Logger.Log(
                 Integration.Models.Enums.LogTypeEnum.Information,
                 $"message: 'API Request Executing', env: '{ConfigurationManager.AppSettings["env"]}', action: '{action}', controller: '{contoller}'",
                 userId,
                 actionContext.Request.GetOwinContext().Request.RemoteIpAddress,
                 actionContext.Request.Headers.UserAgent.ToString());

            base.OnActionExecuting(actionContext);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="actionExecutedContext"></param>
        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            var token = System.Web.HttpContext.Current.Request.Headers["X-Auth-Token"];

            int? userId = TokenManager.UserId(token);

            var action = actionExecutedContext.ActionContext.ActionDescriptor.ActionName;
            var contoller = actionExecutedContext.ActionContext.ActionDescriptor.ControllerDescriptor.ControllerName;
                      
            var result = actionExecutedContext.Response?.Content as ObjectContent;
            var resultStr = "";

            if (result != null && result.Value != null)
            {
                resultStr = result.Value.ToString();

                try
                {
                    resultStr = Json.Encode(result.Value);
                }
                catch (System.Exception)
                {
                    //ignored
                }
            }
            else
            {
                resultStr = " -- Failed to get result";
            }

            var res = actionExecutedContext.Response?.Content;
            if (res != null)
            {
                Task.Factory.StartNew(async () =>
                {
                    BaseResult<object> resultObj = (await res.ReadAsAsync(typeof (BaseResult<object>))) as BaseResult<object>;
                    if (resultObj.ErrorCode == (int)ResponseCodes.Exception)
                    {
                        try
                        {
                            var exceptionStr = new StringBuilder();

                            if (actionExecutedContext.Exception is DbEntityValidationException)
                            {
                                foreach (var entityValidationError in ((DbEntityValidationException)actionExecutedContext.Exception).EntityValidationErrors)
                                {
                                    exceptionStr.AppendLine($"Entity of type \"{entityValidationError.Entry.Entity.GetType().Name}\" in state \"{entityValidationError.Entry.State}\" has the following validation errors:");

                                    foreach (var ve in entityValidationError.ValidationErrors)
                                    {
                                        exceptionStr.AppendLine($"- Property: \"{ve.PropertyName}\", Error: \"{ve.ErrorMessage}\"");
                                    }
                                }

                                exceptionStr.AppendFormat(actionExecutedContext.Exception.ToString());
                            }
                            else
                            {
                                exceptionStr.AppendFormat(actionExecutedContext.Exception.ToString());
                            }

                            Logger.Log(
                                    Integration.Models.Enums.LogTypeEnum.Error,
                                    $"message: 'API Error Excecuting request', action: '{action}', controller: '{contoller}', Exception: '{actionExecutedContext.Exception.Message}. \n\n {exceptionStr}'",
                                    userId,
                                    actionExecutedContext.ActionContext.Request.GetOwinContext().Request.RemoteIpAddress,
                                    actionExecutedContext.ActionContext.Request.Headers.UserAgent.ToString());

                            resultObj.ErrorMessage = "A problem occured while getting results";
                        }
                        catch (Exception)
                        {
                            //Ignored || log to file ???
                        }
                    }
                });
            }

            Logger.Log(
           Integration.Models.Enums.LogTypeEnum.Information,
           $"message: 'API Result Executed', env: '{ConfigurationManager.AppSettings["env"]}',action: '{action}', controller: '{contoller}', response: {resultStr}",
           userId,
           actionExecutedContext.Request.GetOwinContext().Request.RemoteIpAddress,
           actionExecutedContext.Request.Headers.UserAgent.ToString());

            base.OnActionExecuted(actionExecutedContext);
        }

    }
}