using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Authentication;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Web.Http;
using System.Web.Http.Controllers;
using Tango.Logging;
using Tango.Transport.Web;
using Tango.Web.Security;

namespace Tango.Web.Controllers
{
    public class TangoController : ApiController
    {
        protected LogManager LogManager { get; private set; }

        public TangoController()
        {
            LogManager = LogManager.Default;
        }

        public override async Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext context, CancellationToken cancellationToken)
        {
            string controllerName = String.Empty;
            string actionName = String.Empty;

            try
            {
                var routeData = HttpContext.Current.Request.RequestContext.RouteData;
                actionName = routeData.Values["action"].ToString();
                controllerName = routeData.Values["controller"].ToString();
            }
            catch { }

            try
            {
                String request = String.Empty;

                try
                {
                    request = context.Request.Content.ReadAsStringAsync().Result;
                }
                catch { }

                LogManager.Log($"Request Received on {controllerName + "/" + actionName}: \n{request}");

                OnRequestArrived(context.Request);

                var result = await base.ExecuteAsync(context, cancellationToken);
                return result;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, $"An error occurred while processing the request message on {controllerName + "/" + actionName}.");

                HttpStatusCode code = HttpStatusCode.InternalServerError;

                if (ex is ArgumentException || ex is InvalidDataException)
                {
                    code = HttpStatusCode.BadRequest;
                }
                else if (ex is AuthenticationException || ex is TokenExpiredException)
                {
                    code = HttpStatusCode.Unauthorized;
                }
                else if (ex is KeyNotFoundException)
                {
                    code = HttpStatusCode.NotFound;
                }

                HttpResponseException httpException = null;

                if (ex is HttpResponseException httpResponseException)
                {
                    httpException = httpResponseException;
                }
                else
                {
                    httpException = new HttpResponseException(Request.CreateErrorResponse(code, ex.FlattenMessage(), ex));
                }

#if DEBUG
                throw httpException;
#else
                //Remove Stack trace
                var expandedException = httpException.Response.Content as System.Net.Http.ObjectContent<System.Web.Http.HttpError>;

                if (expandedException != null)
                {
                    var expandedExceptionValues = expandedException.Value as HttpError;

                    if (expandedExceptionValues != null)
                    {
                        expandedExceptionValues["StackTrace"] = "";
                    }
                }
#endif


                throw httpException;
            }
        }

        protected virtual void OnRequestArrived(HttpRequestMessage request)
        {
            //Do nothing.
        }
    }

    public class TangoController<T> : TangoController where T : class
    {
        public WebToken<T> RequestToken { get; set; }

        protected override void OnRequestArrived(HttpRequestMessage request)
        {
            base.OnRequestArrived(request);

            var authorizationHeader = request.Headers.Authorization;

            if (authorizationHeader != null)
            {
                try
                {
                    RequestToken = WebToken<T>.FromToken(authorizationHeader.Parameter != null ? authorizationHeader.Parameter : authorizationHeader.ToString());
                }
                catch (Exception ex)
                {
                    throw new HttpParseException("Could not parse the provided token embedded object.", ex);
                }
            }
        }
    }
}