using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Services.Authentication;
using System.ServiceModel.Security;
using System.ServiceModel;

namespace HeuristicLab.Services.Authentication.ServiceClients
{
    public class AuthenticationClient
    {

        private static AuthenticationClient instance;
        public static AuthenticationClient Instance
        {
            get
            {
                if (instance == null) instance = new AuthenticationClient();
                return instance;
            }
        }

        #region Properties

        private IEnumerable<User> users;
        public IEnumerable<User> Users
        {
            get { return users; }
        }
        private IEnumerable<Application> applications;
        public IEnumerable<Application> Applications
        {
            get { return applications; }
        }

        private IEnumerable<Role> roles;
        public IEnumerable<Role> Roles
        {
            get { return roles; }
        }

        #endregion


        private AuthenticationClient()
        {
            applications = CallService<Application[]>(s => s.GetApplications()).OrderBy(x => x.Name);
        }



        #region Store

        public bool Store(AuthItem item)
        {
            try
            {
                if (item.Id == Guid.Empty)
                {
                    if (item is Role)
                        item.Id = CallService<Guid>(s => s.InsertRole((Role)item));
                    else if (item is User)
                        item.Id = CallService<Guid>(s => s.InsertUser((User)item));
                    else if (item is Application)
                        item.Id = CallService<Guid>(s => s.InsertApplication((Application)item));

                }
                else
                {
                    if (item is Role)
                        CallService(s => s.UpdateRole((Role)item));
                    else if (item is User)
                        CallService(s => s.UpdateUser((User)item));
                    else if (item is Application)
                        CallService(s => s.UpdateApplication((Application)item));

                }
                return true;
            }
            catch (Exception ex)
            {
                //ErrorHandling.ShowErrorDialog("Store failed.", ex);
                return false;
            }
        }

        #endregion

        #region Refresh

        public void Refresh()
        {

            var call = new Func<Exception>(delegate()
            {

                Guid applicationId = Guid.Empty; // to be set!

                try
                {
                    users = CallService<User[]>(s => s.GetUsers(applicationId)).OrderBy(x => x.Name);
                    roles = CallService<Role[]>(s => s.GetRoles(applicationId)).OrderBy(x => x.Name);
                    
                    // ...

                    return null;
                }
                catch (Exception ex)
                {
                    return ex;
                }
            });
            call.BeginInvoke(delegate(IAsyncResult result)
            {
                Exception ex = call.EndInvoke(result);
                if (ex != null)
                {
                    //ErrorHandling.ShowErrorDialog("Refresh failed.", ex);
                }

            }, null);
        }


        #endregion

        private T CallService<T>(Func<IAuthenticationService, T> call)
        {
            AuthenticationServiceClient client = new AuthenticationServiceClient();
            client.ClientCredentials.UserName.UserName = "Alice";
            client.ClientCredentials.UserName.Password = "YouWillKnow";
            client.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None;
            //AuthenticationServiceClient client = ClientFactory.Create<AuthenticationClient, IAuthenticationService>();
            try
            {
                return call(client);
            }
            finally
            {
                try
                {
                    client.Close();
                }
                catch (Exception)
                {
                    client.Abort();
                }
            }
        }


        #region Application methods

        public Application GetApplication(Guid applicationId)
        {
            try
            {
                return CallService<Application>(s => s.GetApplication(applicationId));
            }
            catch (Exception ex)
            {
                //ErrorHandling.ShowErrorDialog("Refresh problem data failed.", ex);
                return null;
            }
        }

 
        #endregion


        //public static void Main() {
        //    AuthenticationServiceClient auth = new AuthenticationServiceClient();

        //    auth.ClientCredentials.UserName.UserName = "Alice";
        //    auth.ClientCredentials.UserName.Password = "YouWillKnow";
        //    auth.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None;

        //    Application[] apps = auth.GetApplications();
        //    foreach (Application app in apps) {
        //        Console.WriteLine(app.Name);
        //    }
        //    Console.ReadLine();
        //}
    }
}