using System;
using System.Collections.Generic;
using System.Net;
using RestSharp;
using TS.Insightly.API.Contract;
using TS.Insightly.API.Exception;
using TS.Insightly.API.Utility;

namespace TS.Insightly.API
{
    /// <summary>
    /// Facade for the Insightly API.
    /// Uses RestSharp - https://github.com/restsharp/RestSharp/wiki
    /// </summary>
    public class InsightlyAPI
    {
        #region Fields

        private const string BASE_URL = @"https://api.insight.ly/v2/";

        private readonly string _apiKey;

        #endregion Fields

        /// <summary>
        /// Gets the REST client.
        /// </summary>
        /// <value>
        /// The REST client.
        /// </value>
        internal RestClient Client
        {
            get
            {
                var client = new RestClient();
                client.BaseUrl = BASE_URL;
                client.Authenticator = new HttpBasicAuthenticator(_apiKey, String.Empty);

                return client;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="InsightlyAPI"/> class.
        /// </summary>
        /// <param name="apiKey">The API key.</param>
        public InsightlyAPI(string apiKey)
        {
            _apiKey = apiKey;
        }

        /// <summary>
        /// Executes the specified request.
        /// </summary>
        /// <typeparam name="T">Return type of the data being requested.</typeparam>
        /// <param name="request">The request.</param>
        /// <returns>Data returned by the request.</returns>
        /// <exception cref="TS.Insightly.API.Exception.ResponseException">Error retrieving response.</exception>
        public T Execute<T>(RestRequest request) where T : new()
        {
            var response = Client.Execute<T>(request);

            if (response.ErrorException != null)
            {
                throw new ResponseException("Error retrieving response.", response.ErrorException);
            }

            return response.Data;
        }

        #region Contacts

        /// <summary>
        /// Gets the contact for the unique contact ID.
        /// Note that the Id is not the Id shown for the contact in the web browser, but
        /// the contact Id that is unique to insightly.
        /// </summary>
        /// <param name="contactId">The contact unique identifier.</param>
        /// <returns>The contact for the given id.</returns>
        public Contact GetContact(int contactId)
        {
            var request = new RestRequest(Method.GET);
            request.RequestFormat = DataFormat.Json;
            request.Resource = String.Format("contacts/{0}", contactId);

            return Execute<Contact>(request);
        }

        /// <summary>
        /// Gets the contacts for email address.
        /// </summary>
        /// <param name="emailAddress">The email address.</param>
        /// <returns>List of contacts with a matching email address or empty list if no matches found.</returns>
        public List<Contact> GetContactsForEmail(string emailAddress)
        {
            var request = new RestRequest(Method.GET);
            request.RequestFormat = DataFormat.Json;
            request.Resource = String.Format("contacts?email={0}", emailAddress);

            return Execute<List<Contact>>(request);
        }

        /// <summary>
        /// Adds the new contact.
        /// </summary>
        /// <param name="newContact">The new contact.</param>
        /// <returns>The added contact if successful.</returns>
        public Contact AddNewContact(Contact newContact)
        {
            var request = new RestRequest(Method.POST);
            request.RequestFormat = DataFormat.Json;
            request.Resource = "contacts";
            request.AddBody(newContact);

            var response = Client.Execute<Contact>(request);

            if (response.StatusCode != HttpStatusCode.Created)
            {
                string errorMsg = String.Format("Failed to create contact, response: {0}", response.StatusDescription);
                throw new ContactException(newContact, errorMsg, response.ErrorException);
            }

            return response.Data;
        }

        /// <summary>
        /// Adds the new contact if a contact does not already exist for the same email, 
        /// first and last names as the given contact.
        /// </summary>
        /// <param name="newContact">The new contact.</param>
        /// <returns>Structure containing details of the add.</returns>
        public ContactAddResult AddNewContactIfNotExists(Contact newContact)
        {
            ContactAddResult addResult = new ContactAddResult { NewContactAdded = false, Contact = newContact };

            if (newContact.CONTACTINFOS == null)
            {
                addResult = new ContactAddResult { NewContactAdded = true, Contact = AddNewContact(newContact) };
            }
            else
            {
                bool existingFound = false;

                foreach (var contactInfo in newContact.CONTACTINFOS)
                {
                    if (contactInfo.TYPE.Equals(ContactInfo.InfoType.Email.GetDescription(), StringComparison.InvariantCultureIgnoreCase))
                    {
                        var existingContacts = GetContactsForEmail(contactInfo.DETAIL);

                        foreach (var contact in existingContacts)
                        {
                            if (contact.FIRST_NAME.Equals(newContact.FIRST_NAME, StringComparison.InvariantCultureIgnoreCase)
                                &&
                                contact.LAST_NAME.Equals(newContact.LAST_NAME, StringComparison.InvariantCultureIgnoreCase))
                            {
                                addResult = new ContactAddResult { NewContactAdded = false, Contact = contact };
                                existingFound = true;
                                break;
                            }
                        }
                    }

                    if (existingFound)
                    {
                        break;
                    }
                }
               
                if (!existingFound)
                {
                    addResult = new ContactAddResult { NewContactAdded = true, Contact = AddNewContact(newContact) };
                }
            }

            return addResult;
        }

        /// <summary>
        /// Deletes the contact.
        /// Note that the Id is not the Id shown for the contact in the web browser, but
        /// the contact Id that is unique to insightly.
        /// </summary>
        /// <param name="contactId">The contact unique identifier.</param>
        /// <returns><code>true</code> If the contact was deleted.</returns>
        public bool DeleteContact(int contactId)
        {
            var request = new RestRequest(Method.DELETE);
            request.RequestFormat = DataFormat.Json;
            request.Resource = String.Format("contacts/{0}", contactId);
            
            var response = Client.Execute(request);

            bool result = response.StatusCode == HttpStatusCode.Accepted;

            return result;
        }

        /// <summary>
        /// Result for conditional contact add.
        /// </summary>
        public struct ContactAddResult
        {
            /// <summary>
            /// <code>true</code> If the condition check resulted in a new contact added.
            /// Note if there was an add failure <see cref="Contact"/> may not be valid.
            /// </summary>
            public bool NewContactAdded;

            /// <summary>
            /// The contact, if <see cref="NewContactAdded"/> was <code>true</code> this will
            /// be the newly added contact, otherwise it will be the existing contact.
            /// </summary>
            public Contact Contact;
        }

        #endregion Contacts

        #region Organisations

        /// <summary>
        /// Gets the organisation for the unique organisation ID.
        /// Note that the Id is not the Id shown for the organisation in the web browser, but
        /// the organisation Id that is unique to insightly.
        /// </summary>
        /// <param name="organisationId">The organisation unique identifier.</param>
        /// <returns>The organisation for the given id.</returns>
        public Organisation GetOrganisation(int organisationId)
        {
            var request = new RestRequest(Method.GET);
            request.RequestFormat = DataFormat.Json;
            request.Resource = String.Format("organisations/{0}", organisationId);

            return Execute<Organisation>(request);
        }

        /// <summary>
        /// Gets organisations.
        /// </summary>
        /// <param name="fullDetails">if set to <c>true</c> return full details.</param>
        /// <returns>All organisations.</returns>
        public List<Organisation> GetOrganisations(bool fullDetails)
        {
            var request = new RestRequest(Method.GET);
            request.RequestFormat = DataFormat.Json;
            request.Resource = fullDetails ? "organisations" : "organisations?brief=true";

            return Execute<List<Organisation>>(request);
        }

        /// <summary>
        /// Gets organisations matching the given name.
        /// </summary>
        /// <param name="orgName">Name of the org to find.</param>
        /// <returns>List of organisations (basic details) matching the given name.</returns>
        public List<Organisation> GetOrganisationsForName(string orgName)
        {
            List<Organisation> namedOrgs = new List<Organisation>();
            List<Organisation> allOrgs = GetOrganisations(false);

            foreach (var organisation in allOrgs)
            {
                if (organisation.ORGANISATION_NAME.Equals(orgName, StringComparison.InvariantCultureIgnoreCase))
                {
                    namedOrgs.Add(organisation);
                }
            }

            return namedOrgs;
        }

        /// <summary>
        /// Adds the new organisation.
        /// </summary>
        /// <param name="newOrganisation">The new organisation.</param>
        /// <returns>The added organisation if successful.</returns>
        public Organisation AddNewOrganisation(Organisation newOrganisation)
        {
            var request = new RestRequest(Method.POST);
            request.RequestFormat = DataFormat.Json;
            request.Resource = "organisations";
            request.AddBody(newOrganisation);

            var response = Client.Execute<Organisation>(request);

            if (response.StatusCode != HttpStatusCode.Created)
            {
                string errorMsg = String.Format("Failed to create organisation, response: {0}", response.StatusDescription);
                throw new OrganisationException(newOrganisation, errorMsg, response.ErrorException);
            }

            return response.Data;
        }

        /// <summary>
        /// Deletes the organisation.
        /// Note that the Id is not the Id shown for the organisation in the web browser, but
        /// the organisation Id that is unique to insightly.
        /// </summary>
        /// <param name="organisationId">The organisation unique identifier.</param>
        /// <returns><code>true</code> If the organisation was deleted.</returns>
        public bool DeleteOrganisation(int organisationId)
        {
            var request = new RestRequest(Method.DELETE);
            request.RequestFormat = DataFormat.Json;
            request.Resource = String.Format("organisations/{0}", organisationId);

            var response = Client.Execute(request);

            bool result = response.StatusCode == HttpStatusCode.Accepted;

            return result;
        }

        #endregion Organisations

        #region Projects

        /// <summary>
        /// Gets the project for the unique organisation ID.
        /// Note that the Id is not the Id shown for the project in the web browser, but
        /// the project Id that is unique to insightly.
        /// </summary>
        /// <param name="projectId">The project unique identifier.</param>
        /// <returns>The project for the given id.</returns>
        public Project GetProject(int projectId)
        {
            var request = new RestRequest(Method.GET);
            request.RequestFormat = DataFormat.Json;
            request.Resource = String.Format("projects/{0}", projectId);

            return Execute<Project>(request);
        }

        /// <summary>
        /// Gets projects.
        /// </summary>
        /// <param name="fullDetails">if set to <c>true</c> return full details.</param>
        /// <returns>All projects.</returns>
        public List<Project> GetProjects(bool fullDetails)
        {
            var request = new RestRequest(Method.GET);
            request.RequestFormat = DataFormat.Json;
            request.Resource = fullDetails ? "projects" : "projects?brief=true";

            return Execute<List<Project>>(request);
        }

        #endregion Projects

    }
}