//
//  CalendarApi.cs
//
//  Author:
//       Paul Schneider <paulschneider@free.fr>
//
//  Copyright (c) 2015 - 2017 Paul Schneider
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

using System;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.OptionsModel;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Util.Store;
using Google.Apis.Calendar.v3;
using Google.Apis.Calendar.v3.Data;

namespace Yavsc.Services
{
    using System.Collections.Generic;
    using System.Linq;
    using Google.Apis.Services;
    using Yavsc.Helpers;
    using Yavsc.Models;
    using Yavsc.Models.Calendar;
    using Yavsc.ViewModels.Calendar;

    /// <summary>
    /// Google Calendar API client.
    /// </summary>
    public class CalendarManager : ICalendarManager
	{
        public class ExpiredTokenException : Exception {}
        protected static string scopeCalendar = "https://www.googleapis.com/auth/calendar";
        private string _ApiKey;

		private readonly UserManager<ApplicationUser> _userManager;

		ApplicationDbContext _dbContext;
		ILogger _logger;

		public CalendarManager(IOptions<GoogleAuthSettings> settings,
		UserManager<ApplicationUser> userManager,
		ApplicationDbContext dbContext,
		ILoggerFactory loggerFactory)
		{
            _ApiKey = settings.Value.ApiKey;
			_userManager = userManager;
			_dbContext = dbContext;
			_logger = loggerFactory.CreateLogger<CalendarManager>();
		}

		/// <summary>
		/// The get cal list URI.
		/// </summary>
		protected static string getCalListUri = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
		/// <summary>
		/// The get cal entries URI.
		/// </summary>
		protected static string getCalEntriesUri = "https://www.googleapis.com/calendar/v3/calendars/{0}/events";

		/// <summary>
		/// The date format.
		/// </summary>
		private static string dateFormat = "yyyy-MM-ddTHH:mm:ss";

		/// <summary>
		/// The time zone. TODO Fixme with machine time zone
		/// </summary>
		private string timeZone = "+01:00";

        private readonly IDataStore dataStore = new FileDataStore(GoogleWebAuthorizationBroker.Folder);



		/// <summary>
		/// Gets the calendar list.
		/// </summary>
		/// <returns>The calendars.</returns>
		/// <param name="userId">Yavsc user id</param>
		public async Task<CalendarList> GetCalendarsAsync (string userId)
		{
			var service = new CalendarService();

            var listRequest = service.CalendarList.List();

            return await listRequest.ExecuteAsync();
		}


		private ServiceAccountCredential GetServiceAccountCredential()
		{
			var creds = GoogleHelpers.GetCredentialForApi(new string[]{scopeCalendar});
            if (creds==null)
              throw new InvalidOperationException("No credential");

			return creds;
		}
		/// <summary>
		/// Gets a calendar event list, between the given dates.
		/// </summary>
		/// <returns>The calendar.</returns>
		/// <param name="calid">Calendar identifier.</param>
		/// <param name="mindate">Mindate.</param>
		/// <param name="maxdate">Maxdate.</param>
		/// <param name="cred">credential string.</param>
		public async Task<Events> GetCalendarAsync  (string calid, DateTime mindate, DateTime maxdate)
		{
            var service = new CalendarService();

            var listRequest = service.Events.List(calid);
            return await listRequest.ExecuteAsync();
		}
		public async Task<DateTimeChooserViewModel> CreateViewModelAsync(
			string inputId,
			string calid, DateTime mindate, DateTime maxdate)
		{
			if (calid ==null) return new DateTimeChooserViewModel {
				InputId = inputId,
				MinDate  = mindate,
				MaxDate = maxdate
			};

			var eventList = await GetCalendarAsync(calid, mindate, maxdate);
			List<Period> free = new List<Period> ();
            List<Period> busy = new List<Period> ();
            
            foreach (var ev in eventList.Items)
            {
                DateTime start = ev.Start.DateTime.Value;
                DateTime end = ev.End.DateTime.Value;

                if (ev.Transparency == "transparent" )
                {

                    free.Add(new Period { Start =  start, End = end });
                }
                else busy.Add(new Period { Start = start, End = end });
            }

			return new DateTimeChooserViewModel {
				InputId = inputId,
				MinDate  = mindate,
				MaxDate = maxdate,
				Free = free.ToArray(),
				Busy = busy.ToArray(),
				FreeDates = free.SelectMany( p => new string [] { p.Start.ToString("DD/mm/yyyy"), p.End.ToString("DD/mm/yyyy") }).Distinct().ToArray(),
				BusyDates = busy.SelectMany( p => new string [] { p.Start.ToString("DD/mm/yyyy"), p.End.ToString("DD/mm/yyyy") }).Distinct().ToArray()
			};
		}

/// <summary>
/// Creates a event in a calendar
/// <c>calendar.events.insert</c>
/// </summary>
/// <param name="calid"></param>
/// <param name="startDate"></param>
/// <param name="lengthInSeconds"></param>
/// <param name="summary"></param>
/// <param name="description"></param>
/// <param name="location"></param>
/// <param name="available"></param>
/// <returns></returns>
        public async Task<Event> CreateEventAsync(string calid, DateTime startDate, int lengthInSeconds, string summary, string description, string location, bool available)
        {	
			
			if (string.IsNullOrWhiteSpace (calid))
				throw new Exception ("the calendar identifier is not specified");
			var creds = GetServiceAccountCredential();
GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync();
var computeService = new BaseClientService.Initializer()
{
        HttpClientInitializer = credential
};
computeService.ApiKey = Startup.GoogleSettings.ApiKey;
computeService.ApplicationName = "Yavsc";
computeService.Validate();

            var service = new CalendarService();
            Event ev = new Event {
                Start = new EventDateTime { DateTime = startDate },
                End = new EventDateTime { DateTime = startDate.AddSeconds(lengthInSeconds) },
                Summary = summary,
                Description = description
            };
            var insert = service.Events.Insert(ev,calid);
            var inserted = await insert.ExecuteAsync();
            
            return inserted;
		}
    }
}