using ARC.GMP.Utils;
using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Principal;
using System.Threading.Tasks;
using System.Web;
using System.Web.Configuration;
using System.Web.Mvc;
using System.Web.Routing;
using System.Web.Script.Serialization;

namespace ARC.GMP.Controllers
{
    public class BaseController : Controller
    {
        private string _username = "";
        private string _password = "";
        private string _clientID = "";
        private int _tokenExpire = 30;
        private string _oAuthBaseUrl = "";
        protected ILogger _logger = LogManager.GetCurrentClassLogger();

        public BaseController()
        {
            BaseURL = WebConfigurationManager.AppSettings.Get("GMPWebAPIBaseUrl");
        }

        protected string BaseURL
        {
            get;
            private set;
        }

        internal string Token
        {
            get;
            private set;
        }
        internal string ClientId
        {
            get { return _clientID; }
        }

        protected override void Initialize(RequestContext requestContext)
        {
            _logger.Log(LogLevel.Trace, "**** MVC Controller Initialize start ****");
            _username = WebConfigurationManager.AppSettings["OAuthUsername"];
            _password = WebConfigurationManager.AppSettings["OAuthPassword"];
            _clientID = WebConfigurationManager.AppSettings["OAuthClientId"];
            _oAuthBaseUrl = WebConfigurationManager.AppSettings["OAuthUrl"];
            _tokenExpire = WebConfigurationManager.AppSettings["OAuthTokenExpireTimeout"] == null ? 30 : int.Parse(WebConfigurationManager.AppSettings["OAuthTokenExpireTimeout"].ToString());

            var userDomain = string.Empty;
            var userId = string.Empty;
            var identity = requestContext.HttpContext.Request.LogonUserIdentity as WindowsIdentity;

            _logger.Log(LogLevel.Trace, "Is windows identity: " + identity != null);

            if (identity != null)
            {
                string userName = identity.Name;

                //// FOR TESTING LOCALLY ASSIGNING THE REDCROSS ID
                // userName = "RC\\ajith.alex";

                _logger.Log(LogLevel.Trace, "Username: " + userName);
                var fullUserName = userName.Split(new char[] { '\\' });
                if (fullUserName != null && fullUserName.Length == 2)
                {
                    userDomain = fullUserName[0].Trim();
                    userId = fullUserName[1].Trim();
                }
            }

            _logger.Log(LogLevel.Trace, "**** userId and domain identified ****");
            _logger.Log(LogLevel.Trace, "UserId: " + userId);
            _logger.Log(LogLevel.Trace, "Domain: " + userDomain);

            var Request = System.Web.HttpContext.Current.Request;
            if (Request != null && Request.Cookies["GMPWebToken"] != null)
            {
                if (DateTime.Now > System.Web.HttpContext.Current.Request.Cookies["GMPWebToken"].Expires)
                {
                    Token = "";
                }
                else
                {
                    Token = System.Web.HttpContext.Current.Request.Cookies["GMPWebToken"].Value.ToString();
                }
            }

            _logger.Log(LogLevel.Trace, "**** token set from cookies ****");
            _logger.Log(LogLevel.Trace, "Token: " + Token);

            if (string.IsNullOrEmpty(Token))
            {
                var acctoken = Task.Run(async () => await (new TokenManager()).GetToken(_oAuthBaseUrl, _clientID, _username, _password, userDomain, userId));
                Token = acctoken.Result;

                _logger.Log(LogLevel.Trace, "**** token retrieved from auth server ****");
                _logger.Log(LogLevel.Trace, "Token: " + Token);

                if (!string.IsNullOrEmpty(Token))
                {
                    if (requestContext.HttpContext.Response.Cookies["GMPWebToken"] != null)
                        requestContext.HttpContext.Response.Cookies.Remove("GMPWebToken");

                    requestContext.HttpContext.Response.SetCookie(new System.Web.HttpCookie("GMPWebToken")
                    {
                        Value = Token,
                        Expires = DateTime.Now.AddMinutes(_tokenExpire),
                        HttpOnly = true
                    });
                }
            }

            _logger.Log(LogLevel.Trace, "**** MVC Controller Initialize end ****");
            base.Initialize(requestContext);
        }


        protected JsonResult HandleTrivialHttpRequests(string requestString)
        {
            try
            {
                if (!string.IsNullOrWhiteSpace(requestString))
                {
                    var jsonDeserializer = new JavaScriptSerializer() { MaxJsonLength = int.MaxValue };
                    var JObj = jsonDeserializer.DeserializeObject(requestString);
                    if (JObj is Array)
                    {
                        var results = jsonDeserializer.DeserializeObject(requestString);
                        return JsonReturn(results);
                    }

                    var webServiceStatusResult = JsonConvert.DeserializeObject<WebServiceStatus>(requestString);
                    if (webServiceStatusResult != null && webServiceStatusResult.data != null && typeof(string) == webServiceStatusResult.data.GetType())
                    {
                        var status = webServiceStatusResult.data;

                        if (status.ToString().ToLower().Contains("timedout"))
                        {
                            webServiceStatusResult.data = null;
                            webServiceStatusResult.code = 1;
                            webServiceStatusResult.message = "Unexpected failure.";
                        }
                        else if (status.ToString().ToLower().Contains("error"))
                        {
                            webServiceStatusResult.data = null;
                            webServiceStatusResult.code = 4;
                            webServiceStatusResult.message = "Database error.";
                        }
                        else if (status.ToString().ToLower().Contains("unauthorized"))
                        {
                            webServiceStatusResult.data = null;
                            webServiceStatusResult.code = 3;
                            webServiceStatusResult.message = "Unauthorized access.";
                        }
                        return JsonReturn(webServiceStatusResult);
                    }

                    var result = jsonDeserializer.DeserializeObject(requestString);
                    return JsonReturn(result);
                }
                else
                {
                    return JsonReturn("");
                }
            }
            catch (Exception e)
            {
                _logger.Log(LogLevel.Trace, "**** EXCEPTION: **** " + e.Message);
                _logger.Log(LogLevel.Trace, "**** Stacktrace: **** " + e.StackTrace);
                return JsonReturn("");
            }
        }

        private JsonResult JsonReturn(object result)
        {
            var jsonResult = Json(result, JsonRequestBehavior.AllowGet);
            jsonResult.MaxJsonLength = int.MaxValue;
            jsonResult.RecursionLimit = 100;
            return jsonResult;
        }

        protected override void OnException(ExceptionContext filterContext)
        {
            if (filterContext != null && filterContext.Exception != null)
            {
                filterContext.ExceptionHandled = true;

                filterContext.Result = new JsonResult() { Data = "" };
            }
        }
    }
}