using BuddyFinance.Common.Encryption;
using BuddyFinance.Integration;
using BuddyFinance.Integration.Models;
using BuddyFinance.Integration.Models.Enums;
using BuddyFinance.Integration.Models.Profiles;
using BuddyFinance.WebApi.Filters;
using BuddyFinance.WebApi.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Http;

/*Tumelo 15 Sep 17
 * 
 */

namespace BuddyFinance.WebApi.Controllers
{
    /// <summary>
    /// Profiles API
    /// </summary>
    [RoutePrefix("api/profiles")]
    public class ProfilesController : BaseController
    {
        private ProfilesIntegrator _profileIntegrator = new ProfilesIntegrator();

        /// <summary>
        /// Gets all profiles
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("")]
        [Authenticate]
        public GetProfilesResult GetAllProfiles()
        {
            return _profileIntegrator.GetAllProfiles();
        }

        /// <summary>
        /// Gets profiles by profile type
        /// </summary>
        /// <param name="profileTypeId">profile type Id</param>
        /// <returns></returns>
        [HttpGet]
        [Route("profileTypeId={profileTypeId}")] //api/profiles/profileTypeId={profileTypeId}
        [Authenticate]
        public GetProfilesResult GetProfiles(int profileTypeId)
        {
            return _profileIntegrator.GetProfiles(profileTypeId);
        }

        /// <summary>
        /// Get approved lender profiles
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("approvedlenders")]
        [Authenticate]
        public GetProfilesResult ApprovedLenders()
        {
            var result = GetProfiles((int)ProfileTypeEnum.Lender);
            if (result.Result != null && result.Result.Any())
                result.Result = result.Result.Where(m => m.StatusId == (int)ProfileStatusEnum.Approved).ToList();

            return result;
        }

        /// <summary>
        /// Gets a profile by Id
        /// </summary>
        /// <param name="profileId">profile Id</param>
        /// <returns></returns>
        [HttpGet]
        [Route("{profileId}")] //api/profiles/45
        [Authenticate]
        public GetProfileResult GetProfile(int profileId)
        {
            return _profileIntegrator.GetProfile(profileId);
        }


        /// <summary>
        /// Gets profile notifications
        /// </summary>
        /// <param name="profileId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("{profileId}/notifications")] // api/profiles/45/notifications
        public GetProfileNotificationsResult GetProfileNotifications(string profileId)
        {
            return _profileIntegrator.GetNotifications(profileId);
        }

        /// <summary>
        /// Gets a profile by username
        /// </summary>
        /// <param name="username">username: email</param>
        /// <returns></returns>
        [HttpGet]
        [Route("getbyuser")]
        [Authenticate]
        public GetProfileResult GetProfileByUser(string username)
        {
            return _profileIntegrator.GetProfileByUser(username);
        }

        /// <summary>
        /// Approves a profile application
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("approve")]
        public ApproveProfileResult ApproveProfile(ReviewProfileModel model)
        {
            if (!ModelState.IsValid)
            {
                var errors = "";
                foreach (var modelValue in ModelState.Values)
                {
                    foreach (var modelError in modelValue.Errors)
                    {
                        errors += modelError.ErrorMessage;
                    }
                }

                return new ApproveProfileResult
                {
                    ErrorCode = (int)ResponseCodes.ValidationError,
                    ErrorMessage = errors,

                };
            }

            var userId = model.UserId.ToDecryptedInt();
            return _profileIntegrator.ApproveProfile(model.ProfileId.ToDecryptedInt(), model.Approve, model.Comments, userId);
        }

        /// <summary>
        /// Suspends a profile
        /// </summary>
        /// <param name="model">Suspend info</param>
        /// <returns></returns>
        [HttpPost]
        [Route("suspend")]
        public BaseResult<bool> Suspend(SuspendProfileModel model)
        {
            if (!ModelState.IsValid)
            {
                var errors = "";
                foreach (var modelValue in ModelState.Values)
                {
                    foreach (var modelError in modelValue.Errors)
                    {
                        errors += modelError.ErrorMessage;
                    }
                }

                return new BaseResult<bool>
                {
                    ErrorCode = (int)ResponseCodes.ValidationError,
                    ErrorMessage = errors,
                };
            }

            return _profileIntegrator.Suspend(model);
        }

        /// <summary>
        /// Updates a profile
        /// </summary>
        /// <param name="profile">profile data</param>
        /// <returns></returns>
        [HttpPost]
        [Route("save")]
        public SaveProfileResult SaveProfile(Profile profile) //save status into profileApproval
        {
            return _profileIntegrator.SaveProfile(profile);
        }


        /// <summary>
        /// Approve or decline a profile account
        /// </summary>
        /// <param name="model">profile data</param>
        /// <returns></returns>
        [HttpPost]
        [Route("ReviewAccount")]
        public BaseResult<bool> ReviewAccount(ReviewProfileModel model) 
        {
            return _profileIntegrator.ReviewAccount(model);
        }

        /// <summary>
        /// suspend/unsuspend account
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SuspendAccount")]
        public BaseResult<bool> SuspendAccount(SuspendProfileAccountModel model)
        {
            return _profileIntegrator.SuspendAccount(model);
        }


        /// <summary>
        /// Updates a profile
        /// </summary>
        /// <param name="profile">profile data</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updatedetails")]
        public BaseResult<bool> Update(Profile profile)
        {
            return _profileIntegrator.Update(profile);
        }

        /// <summary>
        /// Updates profile details or create new profile
        /// </summary>
        /// <param name="profileDetails">profile details</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updateprofiledetails")]
        public BaseResult<int> UpdateProfileDetails(ProfileDetails profileDetails)
        {
            return _profileIntegrator.UpdateDetails(profileDetails);
        }

        /// <summary>
        /// Adds or updates profile address
        /// </summary>
        /// <param name="address">profile address</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updateaddress")]
        public UpdateAddressResult UpdateAddress(Address address)
        {
            return _profileIntegrator.UpdateAddress(address);
        }

        /// <summary>
        /// Update profile addresses
        /// </summary>
        /// <param name="addresses"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("updateaddresses")]
        public BaseResult<int> UpdateAddresses(List<Address> addresses)
        {
            return _profileIntegrator.UpdateAddresses(addresses);
        }

        /// <summary>
        /// removes profile address
        /// </summary>
        /// <param name="addressId">Address Id</param>
        /// <returns></returns>
        [HttpPost]
        [Route("removeaddress")]
        public BaseResult<bool> RemoveAddress(int addressId)
        {
            return _profileIntegrator.RemoveAddress(addressId);
        }

        /// <summary>
        /// get profile address
        /// </summary>
        /// <param name="addressId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("getaddress")]
        public BaseResult<Address> GetAddress(int addressId)
        {
            return _profileIntegrator.GetAddress(addressId);
        }

        /// <summary>
        /// get profile addresses
        /// </summary>
        /// <param name="profileId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("{profileId}/addresses")]
        public BaseResult<List<Address>> GetAddresses(int profileId)
        {
            return _profileIntegrator.GetAddresses(profileId);
        }

        /// <summary>
        /// Removes profile document
        /// </summary>
        /// <param name="documentId">Document Id</param>
        /// <returns></returns>
        [HttpPost]
        [Route("removedocument")]
        public BaseResult<bool> RemoveDocument(int documentId)
        {
            return _profileIntegrator.RemoveDocument(documentId);
        }

        /// <summary>
        /// Adds or Updates Profile Document
        /// </summary>
        /// <param name="document">Profile Document</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updatedocument")]
        public UpdateDocumentResult UpdateDocument(Document document)
        {
            return _profileIntegrator.UpdateDocument(document);
        }

        /// <summary>
        /// get profile documents 
        /// </summary>
        /// <param name="profileId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("{profileId}/documents")]
        public BaseResult<List<Document>> GetDocuments(int profileId)
        {
            return _profileIntegrator.GetDocuments(profileId);
        }

        /// <summary>
        /// update profile documents
        /// </summary>
        /// <param name="documents"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateDocuments")]
        public BaseResult<int> UpdateDocuments(List<DocumentEditModel> documents)
        {
            var updateDocuments = documents.Select(m => new Document
            {
                DocumentId = m.DocumentId,
                DocumentTypeId = m.DocumentTypeId,
                FileId = m.FileId,
                ProfileId = m.ProfileId,
                UploadedDate = m.UploadedDate,
                FileData = m.FileData == null 
                           ? null : 
                           new Integration.Models.Files.FileData
                           {
                               Id = m.FileData.Id,
                               FileName = m.UploadFile != null ? m.UploadFile.FileName : m.FileData.FileName,
                               ContentType = m.UploadFile != null ? m.UploadFile.ContentType: m.FileData.ContentType,
                               Size = m.UploadFile != null ? m.UploadFile.ContentLength : m.FileData.Size,
                               Contents = m.UploadFile != null ? Convert.ToBase64String(GetFileContents(m.UploadFile)) : m.FileData.Contents,
                           }
            }).ToList();
            return _profileIntegrator.UpdateDocuments(updateDocuments);
        }

        private byte[] GetFileContents(HttpPostedFileBase uploadFile)
        {
            byte[] data;
            using (Stream inputStream = uploadFile.InputStream)
            {
                MemoryStream memoryStream = inputStream as MemoryStream;
                if (memoryStream == null)
                {
                    memoryStream = new MemoryStream();
                    inputStream.CopyTo(memoryStream);
                }
                data = memoryStream.ToArray();
            }

            return data;
        }

        /// <summary>
        /// Updates Banking details
        /// </summary>
        /// <param name="bankingDetails">Banking details</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updatebankingdetails")]
        public UpdateBankingDetailsResult UpdateBankingDetails(BankingDetail bankingDetails)
        {
            return _profileIntegrator.UpdateBankingDetails(bankingDetails);
        }

        /// <summary>
        /// Updates Employment details
        /// </summary>
        /// <param name="employmentDetail">Employment details</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updateemployment")]
        public UpdateEmploymentResult UpdateEmployment(EmploymentDetail employmentDetail)
        {
            return _profileIntegrator.UpdateEmployment(employmentDetail);
        }

        /// <summary>
        /// Updates Tax information
        /// </summary>
        /// <param name="taxInformation">Tax information</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updatetaxinformation")]
        public UpdateTaxInformationResult UpdateTaxInformation(TaxInformation taxInformation)
        {
            return _profileIntegrator.UpdateTaxInformation(taxInformation);
        }

        /// <summary>
        /// Updates Next of Kin 
        /// </summary>
        /// <param name="nextOfKin">Next of Kin details</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updatenextofkin")]
        public BaseResult<int> UpdateNextOfKin(NextOfKin nextOfKin)
        {
            return _profileIntegrator.UpdateNextOfKin(nextOfKin);
        }

        /// <summary>
        /// Update FICA Compliance information
        /// </summary>
        /// <param name="ficaCompliance">FICA Compliance information</param>
        /// <returns></returns>
        [HttpPost]
        [Route("updatefica")]
        public BaseResult<int> UpdateFica(FicaCompliance ficaCompliance)
        {
            return _profileIntegrator.UpdateFica(ficaCompliance);
        }

        /// <summary>
        /// Return profile summary - Loans and Loan request for borrower
        /// </summary>
        /// <param name="profileId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("summary")] //api/profiles/summary/stjyjzxfaihkfjash ///{profileId}
        public ProfileSummaryResult Summary(string profileId)
        {
            return _profileIntegrator.Summary(profileId);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="profileId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("getProfileEarning")]
        public GetProfileEarnings GetProfileEarnings(string profileId)
        {
            int profileId_ = profileId.ToDecryptedInt();
            return _profileIntegrator.GetProfileEarning(profileId_);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [AllowAnonymous]
        [Route("getearnings")] //api/profiles/getearnings
        public GetProfileEarnings GetProfileEarnings()
        {
            return _profileIntegrator.GetEarning();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        [Route("getloanscalculations")] //api/profiles/getloanscalculations
        public BaseResult<LoanCalculatorResults> LoanCulculator(LoanCalculatorModel model)
        {
            return _profileIntegrator.LoanCulculator(model);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        [Route("contactus")]
        public BaseResult<bool> ContactUs(Contact model)
        {
            return _profileIntegrator.ContactUs(model);
        }

        /// <summary>
        /// Activate profile account
        /// </summary>
        /// <param name="profileId"></param>
        /// <param name="type">type of account to activate (Borrower or Lender)</param>
        /// <returns></returns>
        [HttpPost]
        [Route("activate/{profileId}")]
        public BaseResult<bool> Activate(string profileId, int type)
        {
            var profileId_ = profileId.ToDecryptedInt();
            return _profileIntegrator.Activate(profileId_, type);
        }

        /// <summary>
        /// submit new profile for review
        /// </summary>
        /// <param name="profileId"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("{profileId}/Submit")]
        public BaseResult<Profile> Submit(int profileId)
        {
            //var profileId_ = profileId.ToDecryptedInt();
            return _profileIntegrator.Submit(profileId);
        }
    }
}