using System;
using System.Net;
using Xamarin.Forms;
using IsalaSportmonitor.Repositories;
using IsalaSportmonitor.Models.LocalModels;
using System.Net.Http;
using IsalaSportmonitor.Interfaces;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace IsalaSportmonitor
{
    public partial class Login : ContentPage
    {
        public bool debug;

        /// <summary>
        /// Initializes a new instance of the <see cref="T:IsalaSportmonitor.Login"/> class.
        /// </summary>
        public Login()
        {
            InitializeComponent();
            NavigationPage.SetHasNavigationBar(this, false);

            debug = true;

            HandleSavedUsername();
        }


        //public async void Testlogin(object sender, EventArgs e)
        //{
        //  LoginAPI(null,  null);
        //}

        /// <summary>
        /// This method handles the login process
        /// </summary>
        private async void LoginAPI(object sender, EventArgs e)
        {
            lblmessage.IsVisible = false;
            lblmessage.Text = "";

            // Fill the UserModel
            Models.LoginModel login = new Models.LoginModel();


            if (debug)
            {
                var usrname = "kao7";
                var usrpass = "test123";
                login.Login = usrname;
                login.Wachtwoord = usrpass;

                HttpResponseMessage result = new HttpResponseMessage();
                result = await new ApiRequest().PostAsync("api/login", login);
                result.StatusCode = HttpStatusCode.OK;

                UserRepository.Instance().validateUserOffline(usrname, usrpass);

                //Set user-specific variables
                UserRepository.Instance().login = login;
                UserRepository.Instance().lastActivityTime = DateTime.Now;

                HandleRememberUsername();
                fetchSports();
                acceptAgreement(true);
                return;
            }
            else
            {

                login.Login = username.Text;
                login.Wachtwoord = password.Text;

                // Send UserModel to the API
                HttpResponseMessage result = new HttpResponseMessage();
                result.StatusCode = HttpStatusCode.Forbidden;
                try
                {
                    result = await new ApiRequest().PostAsync("api/login", login);
                }
                catch  //if login failed, try offline login
                {
                    if (UserRepository.Instance().getLocalUserData(this.username.Text) == null)
                    {
                        lblmessage.IsVisible = true;
                        //Message in English: You have to be logged in once through the internet to be able to log in without.
                        lblmessage.Text = "U moet één keer met internet zijn ingelogd om zonder internet te kunnen inloggen.";
                        return;
                    }

                    //Check if user can be validated offline
                    if (UserRepository.Instance().validateUserOffline(this.username.Text, this.password.Text))
                    {
                        //Set user-specific variables
                        UserRepository.Instance().login = login;
                        UserRepository.Instance().lastActivityTime = DateTime.Now;

                        HandleRememberUsername();
                        acceptAgreement();
                        return;
                    }
                }

                //If the login was successful
                if (result.StatusCode == HttpStatusCode.OK)
                {
                    //Set user-specific variables
                    UserRepository.Instance().login = login;
                    UserRepository.Instance().lastActivityTime = DateTime.Now;

                    //save user credentials locally if not yet done
                    if (UserRepository.Instance().getLocalUserData(UserRepository.Instance().login.Login) == null)
                    {
                        UserRepository.Instance().saveUserDataLocally(new LocalUserModel(UserRepository.Instance().login.Login, this.password.Text, false));
                    }
                    else //if local userId exists with other password, then update the password.
                    {
                        if (UserRepository.Instance().getLocalUserData(UserRepository.Instance().login.Login).passwordHash != UserRepository.Instance().hashPassword(this.password.Text))
                        {
                            UserRepository.Instance().updateLocalPassword(UserRepository.Instance().login.Login, this.password.Text);
                        }
                    }

                    HandleRememberUsername();
                    fetchSports();
                    acceptAgreement();
                }
                else if (result.StatusCode == HttpStatusCode.Forbidden)
                {
                    lblmessage.IsVisible = true;
                    //Message in English: The data given was incorrect
                    lblmessage.Text = "De ingevulde gegevens zijn onjuist.";
                }
                else
                {
                    lblmessage.IsVisible = true;
                    //Message in English: There has been an error
                    lblmessage.Text = "Er is een fout opgetreden.";
                }
            }

        }

        #region Other Options

        /// <summary>
        /// This method handles the view for the terms and conditions.
        /// </summary>
        private void ReadTerms(object sender, EventArgs e)
        {
            App.Current.MainPage = new TermsPage();
        }

        /// <summary>
        /// This method handles the agreement that has to be given to the terms and conditions.
        /// </summary>
        public async void acceptAgreement(bool debug = false)
        {
            if (debug)
            {
                UserRepository.Instance().updateAgreementAccept(true);
                App.Current.MainPage = new MasterPage();
            }
            else
            {
                if (!UserRepository.Instance().getLocalUserData(UserRepository.Instance().login.Login).agreementAccepted)
                {
                    //Dialog for accepting terms and conditions
                    var answer = await DisplayAlert("Voorwaarden Accepteren?",
                        "Gaat u akkoord met de algemene voorwaarden voor het gebruik van deze app?",
                        "Ja ik ga akkoord", "Nee ik ga niet akkoord");
                    if (answer)
                    {
                        UserRepository.Instance().updateAgreementAccept(true);
                        App.Current.MainPage = new MasterPage();
                    }
                }
                else
                {
                    App.Current.MainPage = new MasterPage();
                }
            }
        }

        protected override void OnAppearing()
        {
            //var answer = DisplayAlert("Voorwaarden", "Voorwaarden text om mee akkoord te gaan ezno.", "Ja ik ga akkoord.");
        }

        /// <summary>
        /// This method handles the "forgotten password?" event
        /// </summary>
        private void ForgotPassword(object sender, EventArgs e)
        {
            Uri resetUri;
#if DEBUG
            resetUri = new Uri("https://api.sportmonitor.wordt-aan-gewerkt.nl/");
#else
            resetUri = new Uri("https://isalasportmonitor.nl/");
#endif
            Device.OpenUri(resetUri);
        }

        #endregion

        #region username handling

        /// <summary>
        /// This method handles the option to remember the username
        /// </summary>
        private void HandleRememberUsername()
        {
            //Get the status of the switch to remember username
            bool rememberusername = this.switchRememberUsername.IsToggled;

            if (rememberusername)
            {
                //Save the username and the switch value for remembering the username
                bool outcomeRemember = DependencyService.Get<IRememberUsername>().SaveRemember(true);
                bool outcomeName = DependencyService.Get<IRememberUsername>().SaveUsername(this.username.Text);

                if (!outcomeRemember || !outcomeName || (!outcomeRemember && !outcomeName))
                {
                    lblmessage.IsVisible = true;
                    //Message in English: Some setting data could not be saved.
                    lblmessage.Text = "Enkele setting-gegevens konden niet worden opgeslagen.";
                    return;
                }
                else
                {
                    Console.WriteLine("Succes! username saved");
                }
            }
            else
            {
                if (!rememberusername && (DependencyService.Get<IRememberUsername>().GetUsername() == UserRepository.Instance().login.Login))
                {
                    //Clear the username and the switch value for remembering the username
                    bool outcomeRemember = DependencyService.Get<IRememberUsername>().SaveRemember(false);
                    bool outcomeName = DependencyService.Get<IRememberUsername>().SaveUsername("");

                    if (!outcomeRemember || !outcomeName || (!outcomeRemember && !outcomeName))
                    {
                        lblmessage.IsVisible = true;
                        //Message in English: Some setting data could not be saved.
                        lblmessage.Text = "Enkele setting-gegevens konden niet worden opgeslagen.";
                        return;
                    }
                    else
                    {
                        Console.WriteLine("Succes! username forgotten");
                    }
                }
            }
        }

        /// <summary>
        /// This method handles the retreiving of the username, if it has previously been saved (remembered)
        /// </summary>
        private void HandleSavedUsername()
        {

            try
            {
                //Get the remember variable
                bool remember = DependencyService.Get<IRememberUsername>().GetRemember();

                //If true, get the username textfield and toggle the switch to true
                if (remember)
                {
                    this.switchRememberUsername.IsToggled = true;
                    this.username.Text = DependencyService.Get<IRememberUsername>().GetUsername();
                }
                //If false, set the username textfield to an empty string and toggle the switch to false
                else
                {
                    this.switchRememberUsername.IsToggled = false;
                    this.username.Text = "";
                }

            }
            catch (Exception e)
            {
                lblmessage.IsVisible = true;
                //Message in English: Something went wrong retreiving the username.
                lblmessage.Text = "De gebruikersnaam en de switch-data konden niet gevonden worden.";
            }
        }

        #endregion

        /// <summary>
        /// Fetches the sports.
        /// </summary>
        private async void fetchSports()
        {
            //Make an API call for getting all the sports
            HttpResponseMessage sportResponse = new HttpResponseMessage();
            sportResponse.StatusCode = HttpStatusCode.Forbidden;
            sportResponse = await new ApiRequest()
                .SetLogin(UserRepository.Instance().login)
                .Get("api/sport");

            //If API call was successful, get the result and save the sports locally
            if (sportResponse.StatusCode == HttpStatusCode.OK)
            {
                //getting the sports from a JSON format
                var JSON = sportResponse.Content.ReadAsStringAsync();
                var jsonarray = JsonConvert.DeserializeObject(JSON.Result);
                JArray sports = JArray.FromObject(jsonarray);

                //Store each sport locally if it is not yet stored locally
                foreach (JObject sport in sports)
                {
                    bool sportExists = SportRepository.Instance().sportExistsLocally((int)sport["Id"]);
                    if (!sportExists)
                    {
                        try
                        {
                            SportRepository.Instance().storeSportDataLocally(sport);
                        }
                        catch (Exception e)
                        {
                            Console.Write(e);
                        }
                    }
                }
            }
            //Write to console if something is wrong with authentication/authorization
            else if (sportResponse.StatusCode == HttpStatusCode.Forbidden)
            {
                Console.WriteLine("Not the right credentials");
            }
            //Write to console if something else is wrong.
            else
            {
                Console.WriteLine("Something went wrong fetching the sport");
            }

        }

    }
}