NetworkController

using System;
using FormsApp.Model;
using System.Collections.Generic;
using Xamarin.Forms;
using System.Net;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using Newtonsoft.Json;
using System.Threading;
using ModernHttpClient;
using System.Threading.Tasks;
using Connectivity.Plugin;
using PanicModels;

namespace FormsApp.Controllers
{
    public class NetworkManager
    {
//      private static Profile ServerProfile = null;

        public static List<ExternalLoginViewModel> ExternalLogins = new List<ExternalLoginViewModel>();

        private static NetworkManager _networkManager = null;

        public string serverUrl = @"https://geoohrana.ru/";
        public LoginToken sessionToken = null;
        private HttpClient httpClient = null;
        private HttpClient panicHttpClient = null;
        static NetworkManager()
        {
            _networkManager = new NetworkManager();
        }

        public NetworkManager()
        {
            httpClient = Init();
            panicHttpClient = Init();
        }

        public static NetworkManager Instance
        {
            get
            {
                return _networkManager;
            }
        }

        public void InitHttp()
        {
            httpClient = Init();
            panicHttpClient = Init();
        }

        private HttpClient Init()
        {
            var httClient = new HttpClient(new NativeMessageHandler());
            httClient.BaseAddress = new Uri(serverUrl);
            httClient.DefaultRequestHeaders.Accept.Clear();
            httClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            httClient.Timeout = TimeSpan.FromSeconds(40);
            if (sessionToken != null)
                httClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(sessionToken.token_type, sessionToken.access_token);
            return httClient;
        }

        public void SetExternalToken(string token)
        {
            sessionToken = new LoginToken{access_token = token, token_type = "Bearer"};
            sessionToken.expires = DateTime.Now.AddHours(5);
            ProfileController.Instance.SessionToken = JsonConvert.SerializeObject(sessionToken);
            InitHttp();
        }

        public async Task<List<ExternalLoginViewModel>> GetExternalLogins()
        {
            using (var httClient = new HttpClient(new NativeMessageHandler()))
            {
                httClient.BaseAddress = new Uri(serverUrl);
            try
            {
                if (CrossConnectivity.Current.IsConnected)
                {
                    var response = await httClient.GetAsync("api/Account/ExternalLogins?returnUrl=%2F&generateState=true");

                    if (response.IsSuccessStatusCode)
                    {
                        ExternalLogins = await response.Content.ReadAsAsync<List<ExternalLoginViewModel>>();
                        return ExternalLogins;
                    }
                }
                return null;
            }
            catch (Exception ex)
            {
                string exp = ex.Message;
                return null;
            }
            }

        }

        public async Task<ProfileModel> GetProfile ()
        {
            using (var httClient = Init())
            {
            try
            {
                if (CrossConnectivity.Current.IsConnected)
                {
                    var response = await httClient.GetAsync("api/Profile/Load");
                    if (response.IsSuccessStatusCode)
                    {
                        return await response.Content.ReadAsAsync<ProfileModel>();
                    }
                }
                return null;
            }
            catch (Exception ex)
            {
                string exp = ex.Message;
                return null;
            }
            }
        }

        public async Task<string> Login(string username, string password)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try{
                httpClient.CancelPendingRequests();
                string sData = "grant_type=password&username=" + username + "&password=" + password;
                HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                    "application/x-www-form-urlencoded");

                HttpResponseMessage response = await httpClient.PostAsync("Token", content);
                if (response.IsSuccessStatusCode)
                {
                    sessionToken = await response.Content.ReadAsAsync<LoginToken>();
                    sessionToken.expires = DateTime.Now.AddDays((int) (sessionToken.expires_in/60/60/24));
                    ProfileController.Instance.SessionToken = JsonConvert.SerializeObject(sessionToken);
                    InitHttp();
                    return "OK";
                }
                return "Ошибка при входе. Проверьте имя пользователя и пароль";

                    }
                    catch (Exception)
                    {
                        return "Проверьте интернет соединение.";
                    }
            }
            return "Проверьте интернет соединение.";
        }

        public async Task Logout()
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try{
                httpClient.CancelPendingRequests();
                    HttpContent content = new System.Net.Http.StringContent("", System.Text.Encoding.UTF8,
                        "application/x-www-form-urlencoded");
                    HttpResponseMessage response = await httpClient.PostAsync("api/Account/Logout", content);
                    if (response.IsSuccessStatusCode)
                    {

                    }

                    }
                    catch (Exception)
                    {
                        return;
                    }
            }
        }

        public async Task<string> CheckIfPanic(bool defaultValue = false)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                using (var httClient = Init ()) {
                    try {
                        httClient.CancelPendingRequests ();
                        HttpResponseMessage response = await httClient.GetAsync ("api/Panic/CheckIfPanic");
                        if (response.IsSuccessStatusCode) {
                            return (await response.Content.ReadAsAsync<bool> ()).ToString ().ToLower();
                        }else
                        {
                            return "network";
                        }

                    } catch (Exception ex) {
                        return "network";
                    }
                }
            }
            return "network";
        }

        public async Task<string> UpdatePanicGeo(PanicRequest request)
        {
            if (request.Geo.Lat == 0 || request.Geo.Lon == 0)
            {
                return "GPS";
            }
            if (CrossConnectivity.Current.IsConnected)
            {
                panicHttpClient.CancelPendingRequests();
                    string sData = Newtonsoft.Json.JsonConvert.SerializeObject(request);
                    HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                        "application/json");
                HttpResponseMessage response = null;
                try
                {

                    response = await panicHttpClient.PostAsync("api/Panic/Panic", content);
                }
                catch (Exception)
                {
                    return "NETWORK";
                }
                    string managerPhone = null;
                    if (response!= null && response.IsSuccessStatusCode)
                    {
                        managerPhone = await response.Content.ReadAsAsync<string>();
                        return managerPhone;
                    }
                    return "NETWORK";
            }
            return "NETWORK";
        }

        private DateTime lastTrue = DateTime.Now;
        public async Task<bool> CheckIfInArea()
        {
            bool result = false;
                if (CrossConnectivity.Current.IsConnected)
                {
                    panicHttpClient.CancelPendingRequests();
                    string sData = Newtonsoft.Json.JsonConvert.SerializeObject(PanicController.currentGeo);
                    HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                        "application/json");
                    try
                    {
                        HttpResponseMessage response = await panicHttpClient.PostAsync("api/Panic/CheckIfActive", content);
                        if (response.IsSuccessStatusCode)
                        {
                            var resp = await response.Content.ReadAsAsync<string>();
                            if (resp == "OK")
                            {
                                lastTrue = DateTime.Now;
                                return true;
                            }
                        }
                    }
                    catch (Exception)
                    {
                    }
                }
                if (lastTrue.AddSeconds (30) > DateTime.Now)
                    result = true;
                return result;
        }

        public async Task<string> Register(RegisterModel model)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                    sessionToken = null;
                    InitHttp();
                    httpClient.CancelPendingRequests();
                    string sData = Newtonsoft.Json.JsonConvert.SerializeObject(model);
                    HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                        "application/json");

                    HttpResponseMessage response = await httpClient.PostAsync("api/Account/Register", content);
                    if (response.IsSuccessStatusCode)
                    {
                        var resp = await response.Content.ReadAsStringAsync();
                        return "OK";
                    }
                    return response.ReasonPhrase;


                }
                catch (Exception)
                {
                    return "timeout";
                }
            }
            return "404";
        }
        public async Task<bool> RegisterExternal(string username)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                httpClient.CancelPendingRequests();
                string sData = Newtonsoft.Json.JsonConvert.SerializeObject(new RegisterExternalBindingModel{ Email = username});
                HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                    "application/json");

                HttpResponseMessage response = await httpClient.PostAsync("api/Account/RegisterExternal", content);
                if (response.IsSuccessStatusCode)
                {
                    return true;
                }
                return false;

                    }
                    catch (Exception)
                    {
                        return false;
                    }
            }
            return false;
        }

        public class AddExternalLoginBindingModel
        {
            public string ExternalAccessToken { get; set; }
        }


        public async Task<UserInfoViewModel> GetExternalUser()
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try{
                httpClient.CancelPendingRequests();

                HttpResponseMessage response = await httpClient.GetAsync("api/Account/UserInfo");
                if (response.IsSuccessStatusCode)
                {
                    var user = await response.Content.ReadAsAsync<UserInfoViewModel>();/*
                    if (!user.HasRegistered)
                    {
                        string sData = Newtonsoft.Json.JsonConvert.SerializeObject(new AddExternalLoginBindingModel { ExternalAccessToken = sessionToken.access_token});
                        HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                            "application/json");

                        response = await httpClient.PostAsync("api/Account/AddExternalLogin", content);
                        if (response.IsSuccessStatusCode)
                            return user;
                    }
                    response = await httpClient.GetAsync("api/Account/ExternalLogin?provider=" + user.LoginProvider);*/
                    return user;
                }


                }
                catch (Exception)
                {
                    return null;
                }
                return null;
            }
            return null;
        }
        public async Task<bool> ForgotPasswordRequest(string mail)
        {

            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                httpClient.CancelPendingRequests();
                    string sData = Newtonsoft.Json.JsonConvert.SerializeObject(new MailModel {email = mail});
                    HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                        "application/json");

                    HttpResponseMessage response = await httpClient.PostAsync("api/Account/ForgotPassword", content);
                    if (response.IsSuccessStatusCode)
                    {
                        return true;
                    }
                    return false;


                }
                catch (Exception)
                {
                    return false;
                }
            }
            return false;
        }
        public async Task<bool> ResetPassword(ResetModel model)
        {

            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                httpClient.CancelPendingRequests();
                    string sData = Newtonsoft.Json.JsonConvert.SerializeObject(model);
                    HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                        "application/json");

                    HttpResponseMessage response = await httpClient.PostAsync("api/Account/ResetPassword", content);
                    if (response.IsSuccessStatusCode)
                    {
                        return true;
                    }
                    return false;


                }
                catch (Exception)
                {
                    return false;
                }
            }
            return false;
        }

        public async Task<bool> PostImage(ImageModel image)
        {
            using (var httClient = Init())
            {
                try
                {
                    if (CrossConnectivity.Current.IsConnected)
                    {
                        httClient.CancelPendingRequests();
                        string sData = Newtonsoft.Json.JsonConvert.SerializeObject(image);
                        HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                            "application/json");

                        HttpResponseMessage response = await httClient.PostAsync("api/Profile/SaveImage", content);
                        if (response.IsSuccessStatusCode)
                        {
                            return true;
                        }
                        return false;
                    }

                }
                catch (Exception ex)
                {
                    return false;
                }
                return false;
            }
        }

        public async Task<ImageModel> GetImage()
        {
            using (var httClient = Init())
            {

                if (CrossConnectivity.Current.IsConnected)
                {
                    try{
                    HttpResponseMessage response = null;
                    response = await httClient.GetAsync("api/Profile/LoadImage");

                    ImageModel image = null;
                    if (response.IsSuccessStatusCode)
                    {
                        image = await response.Content.ReadAsAsync<ImageModel>();
                        return image;
                    }

                    }
                    catch (Exception)
                    {
                        return null;
                    }
                    return null;
                }
                return null;
            }
        }

        public async Task<List<PeriodModel>> GetPayPeriods()
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                httpClient.CancelPendingRequests();
                    HttpResponseMessage response = await httpClient.GetAsync("api/Content/Periods");
                    List<PeriodModel> periods = null;
                    if (response.IsSuccessStatusCode)
                    {
                        periods = await response.Content.ReadAsAsync<List<PeriodModel>>();
                        return periods;
                    }
                    return null;

                    }
                    catch (Exception)
                    {
                        return null;
                    }
            }
            return null;
        }

        public async Task UpdateProfile(ProfileModel profile, EventHandler onSuccess)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                httpClient.CancelPendingRequests();
                    string sData = Newtonsoft.Json.JsonConvert.SerializeObject(profile);
                    HttpContent content = new System.Net.Http.StringContent(sData, System.Text.Encoding.UTF8,
                        "application/json");
                    HttpResponseMessage response = await httpClient.PostAsync("api/Profile/Save", content);
                    if (response.IsSuccessStatusCode)
                    {
                        var responsedProfile = await response.Content.ReadAsAsync<ProfileModel>();
                        onSuccess(responsedProfile, EventArgs.Empty);
                    }

                    }
                    catch (Exception)
                    {
                        return;
                    }
            }
        }

        public async Task<TextPageModel> GetTerms()
        {
            try
            {
            if (CrossConnectivity.Current.IsConnected)
            {
                try
                {
                httpClient.CancelPendingRequests();
                    httpClient.CancelPendingRequests();
                    HttpResponseMessage response = await httpClient.GetAsync("api/Content/Terms");
                    if (response.IsSuccessStatusCode)
                    {
                        return await response.Content.ReadAsAsync<TextPageModel>();
                    }

                    }
                    catch (Exception)
                {
                    return new TextPageModel { Body = "нет соединения с сервером", Header = "", Name = "" };
                    }
            }
            return new TextPageModel { Body = "нет соединения с сервером", Header = "", Name = "" };
            }
            catch (Exception)
            {
                return new TextPageModel { Body = "нет соединения с сервером", Header = "", Name = "" };
            }
        }

        public async Task<TextPageModel> GetInstructions()
        {
            try
            {
                if (CrossConnectivity.Current.IsConnected)
                {
                    try
                    {
                    httpClient.CancelPendingRequests();
                        HttpResponseMessage response = await httpClient.GetAsync("api/Content/Instructions");
                        if (response.IsSuccessStatusCode)
                        {
                            return await response.Content.ReadAsAsync<TextPageModel>();
                        }

                    }
                    catch (Exception)
                    {
                        return new TextPageModel { Body = "нет соединения с сервером", Header = "", Name = "" };
                    }
                }
                return new TextPageModel { Body = "нет соединения с сервером", Header = "", Name = "" };
            }
            catch (Exception)
            {
                return new TextPageModel { Body = "нет соединения с сервером", Header = "", Name = "" };
            }
        }

        public async Task<List<TariffViewModel>> GetTariffes()
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                httpClient.CancelPendingRequests();
                    var list = new List<TariffViewModel>()
                    {
                        new TariffViewModel(),
                        new TariffViewModel(),
                        new TariffViewModel()
                    };
                try
                {
                    HttpResponseMessage response = await httpClient.GetAsync("api/Content/Tariffes");
                    if (response.IsSuccessStatusCode)
                    {
                        var tariffes = await response.Content.ReadAsAsync<List<TariffModel>>();
                        if (tariffes == null || tariffes.Count < 3)
                            return list;

                        list = tariffes.Select((x) => new TariffViewModel
                        {
                            Name = x.Name,
                            Descriptions = JsonConvert.DeserializeObject<List<TextPageModel>>(x.Descriptions),
                            Price = x.Price,
                            ShortDescription = x.ShortDescription,
                            Id = x.Id,
                            TextColor = x.TextColor,
                            Type = x.Type,
                            ImagePath = ""
                        }).ToList();

                        list[0].ImagePath = "childTariff.png";
                        list[0].TextColor = "#67b8f6";

                        list[1].ImagePath = "standartTariff.png";
                        list[1].TextColor = "#9572ec";

                        list[2].ImagePath = "extremeTariff.png";
                        list[2].TextColor = "#ad3bd3";

                        return list;

                    }


                    }
                    catch (Exception)
                    {
                        return list;
                    }
                    return null;
            }
            return null;
        }
    }
}