using System;

using System.Collections.Generic;

using System.Net.Http;

using System.IO;

using System.Reflection;

using System.Configuration;

using System.Linq;

using System.Xml.Linq;

using System.Xml.XPath;

using System.Text;

using System.Net;

using System.Net.Http.Headers;

using System.Runtime.CompilerServices;

using System.Threading.Tasks;

using CompCare.Shared;

using CompCare.EndpointMgr;

​

namespace CompCare

{

    namespace HTTP

    {

        namespace Client

        {

            public class RemoteClient

            {

                public DeliveryMethod DeliveryMethod

                {

                    get;

                    set;

                }

​

                public ContentNegotiation ContentNegotiation

                {

                    get;

                    set;

                }

​

                private String EndpointAddress

                {

                    get

                    {

                        String sectionName = ClientEndpointSettings.SectionName,

                               assemblyLocation = Assembly.GetEntryAssembly().Location;

​

                        var configuration = ((ClientEndpointSettings)

                            ConfigurationManager.OpenExeConfiguration(assemblyLocation)

                                                .GetSection(sectionName));

​

                        ProfileList profileList = configuration.ProfileList;

                        Service endpoint = profileList.ClientProfile.Service;

​

                        return String.Format("http://{0}:{1}/EnrollMemberInterface", endpoint.Address, endpoint.PortNum);

                    }

                }

​

                private SessionWebClient _csrfWebClientInstanceAccessor = default(SessionWebClient);

​

                private SessionWebClient CsrfWebClientInstanceAccessor

                {

                    get { return _csrfWebClientInstanceAccessor; }

                    set { _csrfWebClientInstanceAccessor = value; }

                }

                private SessionWebClient CsrfWebClientInstance

                {

                    get

                    {

                        string csrfTokenEndpointAddress = String.Format("{0}/GetRequestToken", EndpointAddress);

                        var cookieJar = new CookieContainer();

​

                        var uri = new Uri(csrfTokenEndpointAddress, UriKind.Absolute);

                        var csrfTokenReq = new HttpClient();

​

                        csrfTokenReq.DefaultRequestHeaders

                                    .Add("Content-Type", "text/html");

​

                        string csrfRqstToken = string.Empty;

​

                        Task request = csrfTokenReq.GetAsync(uri)

                            .ContinueWith(response =>

                            {

                                HttpResponseMessage message = response.Result;

                                HttpResponseHeaders responseHeaders = message.Headers;

​

                                var csrfRackRequestTkn = (List<string>)

                                    responseHeaders.GetValues("Request-Token");

​

                                csrfRqstToken = csrfRackRequestTkn[0];

                            });

​

                        request.Start();

                        request.Wait();

​

                        if (CsrfWebClientInstanceAccessor == null)

                        {

                            CsrfWebClientInstanceAccessor = new SessionWebClient();

                            CsrfWebClientInstanceAccessor.Headers.Add("X_CSRF_TOKEN", csrfRqstToken);

​

                            CsrfWebClientInstanceAccessor.BaseAddress = EndpointAddress;

                            CsrfWebClientInstanceAccessor.Headers["ContentType"] = "application/x-www-form-urlencoded";

                        }

​

                        return CsrfWebClientInstanceAccessor;

                    }

​

                    set

                    {

                        CsrfWebClientInstanceAccessor = value;

                    }

                }

​

                static T CastHelper<T>(object obj, T type)

                {

                    return (T)obj;

                }

​

                private SessionWebClient WebClientInit<T>(SessionWebClient instance, params T[] httpHeaders)

                {

                    httpHeaders.ToList()

                        .ForEach((T o) =>

                        {

                            var item = CastHelper(o, new { Key = "", Value = "" });

                            instance.Headers.Add(item.Key, item.Value);

                        });

​

                    return instance;

                }

​

                public RemoteClient()

                {

                }

​

                public Expected<Byte[]> FetchPdfCard(String subscriberNumber, String memberIdNumber, ContentNegotiation contentNegotiationMethod)

                {

                    return Expected<Byte[]>.From(new Byte[]{ })

                        .ThenExecute(delegate(Byte[] array)

                        {   

                            WebClient httpWebRequest = CsrfWebClientInstance;

                            var xmlFetchRequestDoc =

                            new XDocument(

                                new XDeclaration("1.0", "UTF-8", "yes"),

                            new XElement("Messaging",

                                new XAttribute(XNamespace.Xml + "remote", "FetchMemberCardRequest"),

                            new XElement("Configuration",

                                new XAttribute(XNamespace.Xml + "id", "CardOptions"),

                                new XElement("Entry",

                                    new XAttribute("name", "DeliveryMethod"),

                                    DeliveryMethod.Download),

                                new XElement("Entry",

                                    new XAttribute("name", "Filename"),

                                    new XAttribute("ContentNegotiation", contentNegotiationMethod))),

                            new XElement("Container",

                                new XAttribute(XNamespace.Xml + "id", "CardIdentity"),

                                new XElement("Entry",

                                    new XAttribute("name", "SubscriberIdentity"),

                                    subscriberNumber),

                                new XElement("Entry",

                                    new XAttribute("name", "SubscriberIDNumber"),

                                    memberIdNumber)

                            )));

​

                            StringBuilder builder = new StringBuilder()

                                .Append("doc=");

​

                            var writer = new StringWriter(builder);

                            xmlFetchRequestDoc.Save(writer, SaveOptions.None);

                            writer.Flush();

                            writer.Dispose();

                            Byte[] document = ASCIIEncoding.ASCII.GetBytes(

                                builder.ToString(0, builder.Length));

                            return httpWebRequest.UploadData(

                                EndpointAddress, "POST", document);

                        });

                }

​

                // Last|First|MI|Address #1|Address #2|City|State|ZipCd|Birthdate|Gender|Phone No|Medical Records No|Printer Group

                public Expected<String> NewSubscriber(Hospital hospital, OpenLink record)

                {

                    StreamReader reader = default(StreamReader);

                    StringWriter writer = default(StringWriter);

​

                    String methodName = MethodBase.GetCurrentMethod().Name;

                    SessionWebClient httpWebRequest = WebClientInit(CsrfWebClientInstance,

                        new

                        {

                            Key = "SnacRequestMethod",

                            Value = "SyncMemberRequest"

                        });

​

                    return Expected<String>.From("")

                            .ThenExecute(delegate(string s)

                            {

                                String idNumber = String.Empty;

​

                                var doc = new XDocument(

                                    new XDeclaration("1.0", "UTF-8", "yes"),

                                    new XElement("Messaging",

                                        new XAttribute(XNamespace.Xml + "remote", "SyncMemberRequest"),

                                        new XAttribute(XNamespace.Xml + "unique_id", record["Medical Records No"]),

                                        new XAttribute(XNamespace.Xml + "location", hospital.Location),

                                    new XElement("MessagePart",

                                        new XAttribute(XNamespace.Xml + "id", "MemberName"),

                                        new XElement("Entry",

                                            new XAttribute("name", "First"),

                                            record["First"]),

                                        new XElement("Entry",

                                            new XAttribute("name", "Middle"),

                                            record["MI"]),

                                        new XElement("Entry",

                                            new XAttribute("name", "Last"),

                                            record["Last"])),

                                    new XElement("MessagePart",

                                        new XAttribute(XNamespace.Xml + "id", "AddressContainer"),

                                        new XElement("Entry",

                                            new XAttribute("name", "Address"),

                                            record["Address #1"]),

                                        new XElement("Entry",

                                            new XAttribute("name", "City"),

                                            record["City"]),

                                        new XElement("Entry",

                                            new XAttribute("name", "State"),

                                            record["State"]),

                                        new XElement("Entry",

                                            new XAttribute("name", "Zipcode"),

                                            (record["ZipCd"].Trim().Length == 0 ? "0000000" : record["ZipCd"]))

                                    ),

                                    new XElement("MessagePart",

                                        new XAttribute(XNamespace.Xml + "id", "DateContainer"),

                                        new XElement("Entry",

                                            new XAttribute("name", "Birthdate"),

                                            record["Birthdate"]),

                                        new XElement("Entry",

                                            new XAttribute("name", "LastUpdate"),

                                            DateTime.Now)

                                    ),

                                    new XElement("MessagePart",

                                        new XAttribute(XNamespace.Xml + "id", "MiscContainer"),

                                        new XElement("Entry",

                                            new XAttribute("name", "Gender"),

                                            record["Gender"])))

                                    );

​

                                StringBuilder builder = new StringBuilder()

                                    .Append("doc=");

​

                                writer = new StringWriter(builder);

​

                                doc.Save(writer, SaveOptions.None);

                                writer.Flush();

​

                                String response = httpWebRequest.UploadString(EndpointAddress,

                                    "POST", builder.ToString(0, builder.Length));

​

                                writer.Dispose();

                                reader = new StreamReader(response);

​

                                reader.ReadLine();

                                XDocument document = XDocument.Parse(reader.ReadToEnd());

​

                                foreach (XElement element in document.XPathSelectElements("/Messaging/Response"))

                                    idNumber = element.Attribute(XNamespace.Xml + "record_id").Value;

​

                                reader.Dispose();

                                return idNumber;

                            });

                }

            }

        }

    }

}

​