ln.http/ln.http/HttpResponse.cs

using System;
using System.IO;
using System.Collections.Generic;
using ln.json;
using Newtonsoft.Json;

namespace ln.http
{
    public class HttpResponse : IDisposable
    {
        List<HttpCookie> _cookies = new List<HttpCookie>();

        public HttpResponse(HttpStatusCode statusCode)
        {
            HttpStatusCode = statusCode;
            Headers = new HeaderContainer();
        }
        public HttpResponse() : this(HttpStatusCode.OK)
        {
        }
        public HttpResponse(string contentType)
            :this()
        {
            SetHeader("content-type", contentType);
        }
        
        public HeaderContainer Headers { get; }
        public HttpContent HttpContent { get; set; }

        public String GetHeader(string name) => Headers.Get(name);
        public String GetHeader(string name, string defValue) => Headers.Get(name, defValue);

        public void SetHeader(String name, String value) => Headers.Set(name, value);

        public void AddHeader(String name, String value) => Headers.Add(name, value);
        public void RemoveHeader(String name) => Headers.Remove(name);
        public bool ContainsHeader(string headerName) => Headers.Contains(headerName);

        public void AddCookie(string name,string value)
        {
            AddCookie(new HttpCookie(name, value));
        }
        public void AddCookie(HttpCookie httpCookie) => _cookies.Add(httpCookie);
        public void RemoveCookie(HttpCookie httpCookie) => _cookies.Remove(httpCookie);
        public HttpCookie[] Cookies => _cookies.ToArray();

        public HttpStatusCode HttpStatusCode { get; set; }
        

        
        public HttpResponse Header(string name,string value)
        {
            SetHeader(name, value);
            return this;
        }
        public HttpResponse ContentType(string contentType)
        {
            SetHeader("content-type", contentType);
            return this;
        }


        public static HttpResponse OK() => new HttpResponse(HttpStatusCode.OK);
        public static HttpResponse Created() => new HttpResponse(HttpStatusCode.Created);
        public static HttpResponse Accepted() => new HttpResponse(HttpStatusCode.Accepted);
        public static HttpResponse NoContent() => new HttpResponse(HttpStatusCode.NoContent);

        public static HttpResponse MultiStatus() =>
            new HttpResponse(HttpStatusCode.MultiStatus).Header("content-type", "application/xml");

        public static HttpResponse MovedPermanently() => new HttpResponse(HttpStatusCode.MovedPermanently);
        public static HttpResponse SeeOther() => new HttpResponse(HttpStatusCode.SeeOther);
        public static HttpResponse SeeOther(string uri) => new HttpResponse(HttpStatusCode.SeeOther).Header("Location", uri);
        public static HttpResponse TemporaryRedirect() => new HttpResponse(HttpStatusCode.TemporaryRedirect);
        public static HttpResponse PermanentRedirect() => new HttpResponse(HttpStatusCode.PermanentRedirect);

        public static HttpResponse NotFound() => new HttpResponse(HttpStatusCode.NotFound);
        public static HttpResponse BadRequest() => new HttpResponse(HttpStatusCode.BadRequest);
        public static HttpResponse Unauthorized() => new HttpResponse(HttpStatusCode.Unauthorized);
        public static HttpResponse Forbidden() => new HttpResponse(HttpStatusCode.Forbidden);
        public static HttpResponse MethodNotAllowed() => new HttpResponse(HttpStatusCode.MethodNotAllowed);
        public static HttpResponse RequestTimeout() => new HttpResponse(HttpStatusCode.RequestTimeout);
        public static HttpResponse Conflict() => new HttpResponse(HttpStatusCode.Conflict);
        public static HttpResponse UnsupportedMediaType() => new HttpResponse(HttpStatusCode.UnsupportedMediaType);
        public static HttpResponse ImATeapot() => new HttpResponse(HttpStatusCode.ImATeapot);
        public static HttpResponse UpgradeRequired() => new HttpResponse(HttpStatusCode.UpgradeRequired);

        public static HttpResponse InternalServerError() => new HttpResponse(HttpStatusCode.InternalServerError);
        public static HttpResponse NotImplemented() => new HttpResponse(HttpStatusCode.NotImplemented);
        public static HttpResponse BadGateway() => new HttpResponse(HttpStatusCode.BadGateway);
        public static HttpResponse ServiceUnavailable() => new HttpResponse(HttpStatusCode.ServiceUnavailable);
        public static HttpResponse GatewayTimeout() => new HttpResponse(HttpStatusCode.GatewayTimeout);

        public static HttpResponse Default(HttpMethod httpMethod)
        {
            switch (httpMethod)
            {
                case HttpMethod.DELETE:
                    return NoContent();
                case HttpMethod.POST:
                    return Created();
                default:
                    return OK();
            }
        }


        public HttpResponse Content(Exception exception)
        {
            HttpContent = new StringContent(exception.ToString());
            return this;
        }
        public HttpResponse Content(string text)
        {
            HttpContent = new StringContent(text); 
            return this;
        }

        public HttpResponse Content(JSONValue json)
        {
            HttpContent = new JsonContent(json);
            return this;
        }

        public HttpResponse Content(Stream contentStream)
        {
            HttpContent = new StreamContent(contentStream);
            return this;
        }

        public HttpResponse Content(HttpContent httpContent)
        {
            HttpContent = httpContent;
            return this;
        }

        public HttpResponse Json<T>(T content)
        {
            HttpContent = new StringContent(JsonConvert.SerializeObject(content), "application/json");
            return this;
        }
        
        public void Dispose()
        {
            HttpContent?.Dispose();
        }
    }
}