/*
 *  Copyright 2017 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.plugins.zimbra;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.stream.Collectors;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.Redirector;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.collections.ListUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HeaderElement;
import org.apache.http.HeaderElementIterator;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.ConnectionPoolTimeoutException;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeaderElementIterator;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.JSONUtils;
import org.ametys.plugins.messagingconnector.AbstractMessagingConnector;
import org.ametys.plugins.messagingconnector.CalendarEvent;
import org.ametys.plugins.messagingconnector.EmailMessage;
import org.ametys.plugins.messagingconnector.MessagingConnectorException;
import org.ametys.runtime.config.Config;

import net.fortuna.ical4j.data.CalendarBuilder;
import net.fortuna.ical4j.data.ParserException;
import net.fortuna.ical4j.model.Calendar;
import net.fortuna.ical4j.model.Component;
import net.fortuna.ical4j.model.ComponentList;
import net.fortuna.ical4j.model.DateTime;
import net.fortuna.ical4j.model.Period;
import net.fortuna.ical4j.model.PeriodList;
import net.fortuna.ical4j.model.component.VEvent;
import net.fortuna.ical4j.model.property.DtEnd;
import net.fortuna.ical4j.model.property.DtStart;
import net.fortuna.ical4j.model.property.Location;
import net.fortuna.ical4j.model.property.Summary;

/**
 * 
 * The connector used by the messaging connector plugin when the zimbra mail
 * server is used. Implements the methods of the MessagingConnector interface in
 * order to get the informations from the mail server
 *
 */
public class ZimbraConnector extends AbstractMessagingConnector implements Disposable
{
    /** The number of seconds after what kept alive connections are dropt */
    protected static final int _DROP_KEPTALIVE_CONNECTION_AFTER = 5;
    
    /** The user manager */
    protected UserManager _usersManager;

    /** The JSON Utils */
    protected JSONUtils _jsonUtils;

    /** Url to zimbra */
    protected String _zimbraUrl;

    /** Preauth secret key */
    protected String _domainPreauthSecretKey;

    /** Request to the remote app will be ppoled for perfs purposes */
    protected PoolingHttpClientConnectionManager _connectionManager;
    /** The keep-alive stragegy to optimize http clients */
    protected ConnectionKeepAliveStrategy _connectionKeepAliveStrategy;
    /** The shared configuration for request (for timeout purposes) */
    protected RequestConfig _connectionConfig;

    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        super.service(smanager);
        _usersManager = (UserManager) smanager.lookup(UserManager.ROLE);
        _jsonUtils = (JSONUtils) smanager.lookup(JSONUtils.ROLE);
    }

    @Override
    public void initialize()
    {
        super.initialize();
        _zimbraUrl = StringUtils.removeEnd(Config.getInstance().getValue("zimbra.config.zimbra.baseUrl"), "/");
        _domainPreauthSecretKey = Config.getInstance().getValue("zimbra.config.preauth.key");
        
        int maxSimultaneousConnections = (int) (long) Config.getInstance().getValue("zimbra.config.maxconnections");
        // Same value for 3 timeouts (socket, connection and response) so one connection can last 3 times this value
        int connectionTimeout = (int) Math.max(0, (long) Config.getInstance().getValue("zimbra.config.timeout"));  
        
        // A pooling connection manager to avoid flooding remote server by reusing existing connections AND by limiting their number
        _connectionManager = new PoolingHttpClientConnectionManager();
        _connectionManager.setMaxTotal(maxSimultaneousConnections > 0 ? maxSimultaneousConnections : Integer.MAX_VALUE);
        _connectionManager.setDefaultMaxPerRoute(maxSimultaneousConnections > 0 ? maxSimultaneousConnections : Integer.MAX_VALUE);
        
        // inspired from http://www.baeldung.com/httpclient-connection-management
        // to keep a connection alive for a few seconds if the remote server did not send back this information
        _connectionKeepAliveStrategy = new ConnectionKeepAliveStrategy() 
        {
            @Override
            public long getKeepAliveDuration(HttpResponse response, HttpContext context) 
            {
                HeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                while (it.hasNext()) 
                {
                    HeaderElement he = it.nextElement();
                    String param = he.getName();
                    String value = he.getValue();
                    if (value != null && param.equalsIgnoreCase("timeout")) 
                    {
                        try
                        {
                            return Long.parseLong(value) * 1000;
                        }
                        catch (NumberFormatException ignore) 
                        {
                            // Ignore
                        }
                    }
                }
                return _DROP_KEPTALIVE_CONNECTION_AFTER * 1000;
            }
        };
        
        _connectionConfig = RequestConfig.custom()
                .setConnectTimeout(connectionTimeout * 1000)
                .setConnectionRequestTimeout(connectionTimeout * 1000) // Time to get an object from the pool
                .setSocketTimeout(connectionTimeout * 1000).build();
    }
    
    public void dispose()
    {
        _connectionManager.close();
    }
    
    /**
     * Get a new pooled http client. Do not forget to close it.
     * @return The client
     */
    protected CloseableHttpClient _getHttpClient()
    {
        return HttpClients.custom()
                .setConnectionManager(_connectionManager)
                .setConnectionManagerShared(true) // avoid automatic pool closing
                .setKeepAliveStrategy(_connectionKeepAliveStrategy)
                .setDefaultRequestConfig(_connectionConfig)
               .build();
    }

    /**
     * Preauth user and redirect to the zimbra application
     * @param redirector The redirector
     * @param targetApp The zimbra application (ex: mail) 
     * @throws ProcessingException if failed to redirect
     * @throws IOException if failed to redirect
     */
    public void redirect(Redirector redirector, String targetApp) throws ProcessingException, IOException
    {
        UserIdentity identity = _currentUserProvider.getUser();
        User user = _usersManager.getUser(identity);
        
        if (user != null)
        {
            String qs = _computeQueryString(user, targetApp);
            if (qs != null)
            {
                redirector.redirect(false, _zimbraUrl + "/service/preauth?" + qs);
            }
        }
    }
    
    /**
     * Retrieves some mail info through a query via the Zimbra REST API. Query
     * used is :
     * home/~/inbox?query=is:unread&fmt=json&auth=qp&zauthtoken=##TOKEN##
     * @param user The user
     * @param zmAuthToken The auth token corresponding to a currenlty logged
     *            user in zimbra.
     * @return Map of info returned by the REST request
     */
    protected Map<String, Object> _getEmailInfo(User user, String zmAuthToken)
    {
        // Preauth request parameters
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("fmt", "json")); // Request json format Restrict to unread messages from the inbox folder.
        params.add(new BasicNameValuePair("query", "is:unread")); // Restrict to unread messages from the inbox folder.
        params.add(new BasicNameValuePair("auth", "qp")); // Requires authentication token method
        params.add(new BasicNameValuePair("zauthtoken", zmAuthToken)); // Authentication token

        // Computing query string
        String qs = URLEncodedUtils.format(params, StandardCharsets.UTF_8);

        // Rest API URL. '~' stands for the current active user, which is
        // retrieved through the auth token b/c auth token method is used (see
        // query string params)
        HttpGet get = new HttpGet(_zimbraUrl + "/home/~/inbox?" + qs);

        try (CloseableHttpClient httpClient = _getHttpClient(); CloseableHttpResponse response = httpClient.execute(get, HttpClientContext.create()))
        {
            String content = EntityUtils.toString(response.getEntity());
            return _jsonUtils.convertJsonToMap(content);
        }
        catch (UnknownHostException e)
        {
            throw new MessagingConnectorException("Unknown host for zimbra server. Giving up to get Zimbra emails for user " + user, MessagingConnectorException.ExceptionType.CONFIGURATION_EXCEPTION, e);
        }
        catch (ConnectionPoolTimeoutException | SocketTimeoutException e)
        {
            throw new MessagingConnectorException("There are already too many connections to Zimbra server. Giving up to get Zimbra emails for user " + user, MessagingConnectorException.ExceptionType.TIMEOUT, e);
        }
        catch (IOException e)
        {
            throw new MessagingConnectorException("Failed to get Zimbra emails for user " + user, MessagingConnectorException.ExceptionType.UNKNOWN, e);
        }
    }

    /**
     * Retrieves a calendar through a query via the Zimbra REST API.
     * Query used is :
     * home/~/calendar?fmt=ics&amp;end=p30d&amp;auth=qp&amp;zauthtoken=##TOKEN##
     * @param user The user
     * @param zmAuthToken The auth token corresponding to a currenlty logged
     *            user in zimbra.
     * @param dayInterval Interval of day to search for the next event
     * @return The Calendar
     */
    protected Calendar _getCalendar(User user, String zmAuthToken, String dayInterval)
    {
        // Preauth request parameters
        String relativeEnd = "p" + dayInterval + "d";
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("fmt", "ics")); // Request iCAL format
        params.add(new BasicNameValuePair("start", "p0mi")); // Interval starts from now
        params.add(new BasicNameValuePair("end", relativeEnd)); // and ends after the configured number of days.
        params.add(new BasicNameValuePair("auth", "qp")); // Requires authentication token method
        params.add(new BasicNameValuePair("zauthtoken", zmAuthToken)); // Authentication token

        // Computing query string
        String qs = URLEncodedUtils.format(params, StandardCharsets.UTF_8);

        // Rest API URL. '~' stands for the current active user, which is
        // retrieved through the auth token b/c auth token method is used
        // (see query string params)
        HttpGet get = new HttpGet(_zimbraUrl + "/home/~/calendar?" + qs);

        try (CloseableHttpClient httpClient = _getHttpClient(); CloseableHttpResponse response = httpClient.execute(get, HttpClientContext.create()); InputStream responseIs = response.getEntity().getContent())
        {
            // Construct the iCAL calendar from the response input stream.
            CalendarBuilder builder = new CalendarBuilder();
            Calendar calendar = builder.build(responseIs);
            return calendar;
        }
        catch (UnknownHostException e)
        {
            throw new MessagingConnectorException("Unknown host for zimbra server. Giving up to get Zimbra calendar events for user " + user, MessagingConnectorException.ExceptionType.CONFIGURATION_EXCEPTION, e);
        }
        catch (ConnectionPoolTimeoutException | SocketTimeoutException e)
        {
            throw new MessagingConnectorException("There are already too many connections to zimbra server. Giving up to get Zimbra calendar events for user " + user, MessagingConnectorException.ExceptionType.TIMEOUT, e);
        }
        catch (ParserException | IOException e)
        {
            throw new MessagingConnectorException("Failed to get Zimbra calendar events for user " + user, MessagingConnectorException.ExceptionType.UNKNOWN, e);
        }
    }

    /**
     * Extract interesting properties for the calendar. Retrieves the next
     * events and return some info.
     * @param calendar The calendar
     * @param dayInterval Interval of day to search for the next event
     * @param maxEvents The maximum number of events
     * @return map of info about the next events.
     */
    protected List<Map<String, Object>> _extractCalendarProperties(Calendar calendar, int dayInterval, int maxEvents)
    {
        // Retrieving events.
        ComponentList components = calendar.getComponents(Component.VEVENT);
        List<VEvent> events = ListUtils.typedList(components, VEvent.class);

        // Iterates over all events to find the closest date from now (taking
        // recurring events into account). Constructs a sorted map where keys
        // are next closest dates for each event, and values are the
        // corresponding events.
        SortedMap<Date, ZimbraEvent> eventMap = new TreeMap<>(new Comparator<Date>()
        {
            @Override
            public int compare(Date d1, Date d2)
            {
                return d1.compareTo(d2);
            }
        });

        LocalDateTime nowLdt = LocalDateTime.now();
        Date fromDate = DateUtils.asDate(nowLdt.withSecond(0));
        Date untilDate = DateUtils.asDate(nowLdt.withHour(0).withMinute(0).withSecond(0).plusDays(dayInterval));
        
        DateTime start = new DateTime(fromDate);
        DateTime end = new DateTime(untilDate);

        for (VEvent event : events)
        {
            PeriodList consumedTime = event.getConsumedTime(start, end);
            Iterator periodIterator = consumedTime.iterator();
            
            while (periodIterator.hasNext())
            {
                Period period = (Period) periodIterator.next();
                Date pStart = period.getStart();
                Date pEnd = period.getEnd();
                
                if (pStart != null)
                {
                    eventMap.put(pStart, new ZimbraEvent(event, pStart, pEnd));
                }
            }
        }

        return eventMap.entrySet().stream().limit(maxEvents).map(e -> _extractCalendarProperties(e.getValue())).collect(Collectors.toList());
    }

    /**
     * Extract interesting properties for the event.
     * @param zimbraEvent The event
     * @return map of interesting info about this event.
     */
    protected Map<String, Object> _extractCalendarProperties(ZimbraEvent zimbraEvent)
    {
        Map<String, Object> properties = new HashMap<>();
        
        VEvent event = zimbraEvent.getEvent();
        Date startDate = zimbraEvent.getStartDate();
        Date endDate = zimbraEvent.getEndDate();

        if (event != null && startDate != null && endDate != null)
        {
            properties.put("eventStartDateRaw", startDate);

            properties.put("eventEndDate", endDate);
            
            // Location
            Location location = event.getLocation();
            if (location != null)
            {
                String eventLocation = _sanitizeEventLocation(location);
                properties.put("eventLocation", eventLocation);
            }

            // Summary
            Summary summary = event.getSummary();
            if (summary != null)
            {
                properties.put("eventSubject", summary.getValue());
            }
        }
        else
        {
            properties.put("eventNothing", true);
        }

        return properties;
    }

    /**
     * Extract the interesting part of the raw event location.
     * @param location The iCal4j location object.
     * @return A String representing the sanitized location.
     */
    protected String _sanitizeEventLocation(Location location)
    {
        String extractedValue = location.getValue();

        if (StringUtils.contains(extractedValue, ';'))
        {
            extractedValue = StringUtils.substringBefore(extractedValue, ";");
        }

        String candidateValue = StringUtils.substringBetween(extractedValue, "\"");
        if (StringUtils.isNotBlank(candidateValue))
        {
            extractedValue = candidateValue;
        }

        return extractedValue;
    }

    /**
     * Zimbra preauth request to log the current user into zimbra and retrieve the ZM_AUTH_TOKEN
     * @param user The user for which the preauth request will be done.
     * @return The Zimbra ZM_AUTH_TOKEN which can be used in future request made through the Zimbra REST API or <code>null</code> if user is null or has no email.
     * @throws MessagingConnectorException if failed to get zimbra token for user
     */
    protected String _doPreauthRequest(User user)
    {
        // Computing query string
        String qs = _computeQueryString(user, null);
        if (qs == null)
        {
            return null;
        }
        
        HttpGet get = new HttpGet(_zimbraUrl + "/service/preauth?" + qs);

        try (CloseableHttpClient httpClient = _getHttpClient())
        {
            HttpClientContext context = HttpClientContext.create();
            try (CloseableHttpResponse response = httpClient.execute(get, context))
            {
                List<Cookie> cookies = context.getCookieStore().getCookies();
    
                for (Cookie cookie : cookies)
                {
                    if (StringUtils.equals(cookie.getName(), "ZM_AUTH_TOKEN"))
                    {
                        return cookie.getValue();
                    }
                }
    
                throw new MessagingConnectorException("Zimbra authentification failed for user " + user.getEmail(), MessagingConnectorException.ExceptionType.CONFIGURATION_EXCEPTION);
            }
        }
        catch (UnknownHostException e)
        {
            throw new MessagingConnectorException("Unknown host for zimbra server. Giving up to proceed to the Zimbra preauth action for user " + user, MessagingConnectorException.ExceptionType.CONFIGURATION_EXCEPTION, e);
        }
        catch (ConnectionPoolTimeoutException | SocketTimeoutException e)
        {
            throw new MessagingConnectorException("There are already too many connections to zimbra server. Giving up to proceed to the Zimbra preauth action for user " + user, MessagingConnectorException.ExceptionType.TIMEOUT, e);
        }
        catch (IOException e)
        {
            throw new MessagingConnectorException("Unable to proceed to the Zimbra preauth action for user : " + user.getEmail(), MessagingConnectorException.ExceptionType.UNKNOWN, e);
        }
    }
    
    private String _computeQueryString(User user, String targetApp)
    {
        if (user == null)
        {
            return null;
        }

        String zimbraUser = user.getEmail();

        if (StringUtils.isEmpty(zimbraUser))
        {
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("Cannot retreive zimbra information with empty email for user " + user);
            }
            return null;
        }

        String timestamp = String.valueOf(System.currentTimeMillis());
        String computedPreauth = null;

        try
        {
            computedPreauth = _getComputedPreauth(zimbraUser, timestamp, _domainPreauthSecretKey);
        }
        catch (Exception e)
        {
            throw new MessagingConnectorException("Unable to compute the preauth key during the Zimbra preauth action for user : " + zimbraUser, MessagingConnectorException.ExceptionType.UNKNOWN, e);
        }

        // Preauth request parameters
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("account", zimbraUser));
        params.add(new BasicNameValuePair("timestamp", timestamp));
        params.add(new BasicNameValuePair("expires", "0"));
        params.add(new BasicNameValuePair("preauth", computedPreauth));
        if (targetApp != null)
        {
            params.add(new BasicNameValuePair("redirectURL", "/?app=" + targetApp));
        }
        
        // Computing query string
        return URLEncodedUtils.format(params, StandardCharsets.UTF_8);
    }

    /**
     * Compute the preauth key.
     * @param zimbraUser The Zimbra User
     * @param timestamp The timestamp
     * @param secretKey The secret key
     * @return The computed preauth key
     * @throws NoSuchAlgorithmException if no Provider supports a MacSpi
     *             implementation for the specified algorithm (HmacSHA1).
     * @throws InvalidKeyException if the given key is inappropriate for
     *             initializing the MAC
     * @throws UnsupportedEncodingException If the named charset (UTF-8) is not
     *             supported
     */
    protected String _getComputedPreauth(String zimbraUser, String timestamp, String secretKey) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException
    {
        SecretKeySpec signingKey = new SecretKeySpec(secretKey.getBytes(), "HmacSHA1");
        Mac mac = Mac.getInstance("HmacSHA1");
        mac.init(signingKey);

        String data = StringUtils.join(new String[] {zimbraUser, "name", "0", timestamp}, '|');
        byte[] rawHmac = mac.doFinal(data.getBytes());
        byte[] hexBytes = new Hex().encode(rawHmac);
        return new String(hexBytes, "UTF-8");
    }

    @Override
    protected List<CalendarEvent> internalGetEvents(UserIdentity userIdentity, int maxDays, int maxEvents) throws MessagingConnectorException
    {
        // Connection to the zimbra mail server
        User user = _usersManager.getUser(userIdentity);
        String authToken = _doPreauthRequest(user);
        
        if (StringUtils.isEmpty(authToken))
        {
            return Collections.EMPTY_LIST;
        }
        
        List<CalendarEvent> calendarEvent = new ArrayList<>();
        // Collect the list of events
        Calendar calendar = _getCalendar(user, authToken, String.valueOf(maxDays));
        List<Map<String, Object>> vevents = _extractCalendarProperties(calendar, maxDays, maxEvents);
        for (Map<String, Object> vevent : vevents)
        {
            // Creating the CalendarEvent
            CalendarEvent newEvent = new CalendarEvent();
            newEvent.setStartDate((Date) vevent.get("eventStartDateRaw"));
            newEvent.setEndDate((Date) vevent.get("eventEndDate"));
            newEvent.setSubject((String) vevent.get("eventSubject"));
            newEvent.setLocation((String) vevent.get("eventLocation"));
            calendarEvent.add(newEvent);
        }
        return calendarEvent;
    }

    @Override
    protected int internalGetEventsCount(UserIdentity userIdentity, int maxDays) throws MessagingConnectorException
    {
        // Connection to the zimbra mail server
        User user = _usersManager.getUser(userIdentity);
        String authToken = _doPreauthRequest(user);
        
        if (StringUtils.isEmpty(authToken))
        {
            return 0;
        }
        
        return _getCalendar(user, authToken, String.valueOf(maxDays)).getComponents(Component.VEVENT).size();
    }

    @SuppressWarnings("unchecked")
    @Override
    protected List<EmailMessage> internalGetEmails(UserIdentity userIdentity, int maxEmails) throws MessagingConnectorException
    {
        // Connection to the zimbra mail server
        User user = _usersManager.getUser(userIdentity);
        String authToken = _doPreauthRequest(user);
        
        if (StringUtils.isEmpty(authToken))
        {
            return Collections.EMPTY_LIST;
        }
        
        Map<String, Object> mailInfo = _getEmailInfo(user, authToken);

        List<EmailMessage> listMail = new ArrayList<>();

        if (mailInfo != null && !mailInfo.isEmpty())
        {
            if (mailInfo.values().iterator().next() instanceof Collection)
            {
                Collection<LinkedHashMap<String, Object>> mailObject = (Collection<LinkedHashMap<String, Object>>) mailInfo.values().iterator().next();
                for (LinkedHashMap<String, Object> mailObjectMap : mailObject)
                {
                    if (listMail.size() < maxEmails)
                    {
                        EmailMessage newMail = new EmailMessage();
                        if (mailObjectMap.get("e") instanceof List)
                        {
                            List<LinkedHashMap<String, Object>> mailObjectPerson = (List<LinkedHashMap<String, Object>>) mailObjectMap.get("e");
                            newMail.setSender(mailObjectPerson.get(1).get("a").toString()); // get the sender
                        }
                        newMail.setSubject(mailObjectMap.get("su").toString()); // get the subject
                        newMail.setSummary(mailObjectMap.get("fr").toString()); // get the summary
                        listMail.add(newMail);
                    }
                }
            }
        }
        else if (getLogger().isWarnEnabled())
        {
            getLogger().warn("Zimbra returned empty information for user " + userIdentity);
        }
        return listMail;
    }

    @SuppressWarnings("unchecked")
    @Override
    protected int internalGetEmailsCount(UserIdentity userIdentity) throws MessagingConnectorException
    {
        // Connection to the zimbra mail server
        User user = _usersManager.getUser(userIdentity);
        String authToken = _doPreauthRequest(user);
        
        if (StringUtils.isEmpty(authToken))
        {
            return 0;
        }
        
        Map<String, Object> mailInfo = _getEmailInfo(user, authToken);
        if (mailInfo != null && !mailInfo.isEmpty())
        {
            return ((Collection<LinkedHashMap<String, Object>>) mailInfo.values().iterator().next()).size();
        }
        
        if (getLogger().isWarnEnabled())
        {
            getLogger().warn("Zimbra returned empty information for user " + userIdentity);
        }
        
        return 0;
    }
    
    private class ZimbraEvent
    {
        private VEvent _event;
        private Date _startDate;
        private Date _endDate;
        
        /**
         * Default constructor
         * @param event The event
         * @param startDate The start of the event
         * @param endDate The end of the event
         */
        public ZimbraEvent(VEvent event, Date startDate, Date endDate)
        {
            _event = event;
            _startDate = startDate;
            _endDate = endDate;
        }

        /**
         * Get the event
         * @return the event
         */
        public VEvent getEvent()
        {
            return _event;
        }

        /**
         * Get the start date
         * @return the startDate
         */
        public Date getStartDate()
        {
            return _startDate != null ? _startDate : Optional.of(_event)
                    .map(VEvent::getStartDate)
                    .map(DtStart::getDate)
                    .orElse(null);
        }

        /**
         * Get the end date
         * @return the endDate
         */
        public Date getEndDate()
        {
            return _endDate != null ? _startDate : Optional.of(_event)
                    .map(VEvent::getEndDate)
                    .map(DtEnd::getDate)
                    .orElse(null);
        }
        
        
    }
}