/*
 *  Copyright 2015 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.runtime.plugins.admin.system;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.time.ZonedDateTime;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.xml.sax.helpers.AttributesImpl;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.ui.Callable;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.I18nUtils;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.servlet.RuntimeConfig;
import org.ametys.runtime.util.AmetysHomeHelper;

/**
 * Helper for manipulating system announcement
 */
public class SystemHelper extends AbstractLogEnabled implements Component, Serviceable, Contextualizable, Initializable
{
    /** The relative path to the file where system information are saved (announcement, maintenance...) */
    public static final String ADMINISTRATOR_SYSTEM_FILENAME = "system.xml";
    /** Avalon role */
    public static final String ROLE = SystemHelper.class.getName();
    
    private static final String SYSTEM_ANNOUNCEMENT_CACHE = SystemHelper.class.getName() + "$SystemAnnouncement";
    private static final String SYSTEM_ANNOUNCEMENT_CACHE_KEY = SystemHelper.class.getName() + "$SystemAnnouncement";
    
    
    private I18nUtils _i18nUtils;
    private Context _context;
    private AbstractCacheManager _cacheManager;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _i18nUtils = (I18nUtils) serviceManager.lookup(I18nUtils.ROLE);
        _cacheManager = (AbstractCacheManager) serviceManager.lookup(AbstractCacheManager.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _cacheManager.createMemoryCache(SYSTEM_ANNOUNCEMENT_CACHE,
                new I18nizableText("plugin.admin", "PLUGINS_ADMIN_CACHE_SYSTEM_ANNOUNCEMENT_LABEL"),
                new I18nizableText("plugin.admin", "PLUGINS_ADMIN_CACHE_SYSTEM_ANNOUNCEMENT_DESCRIPTION"),
                true,
                null);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    /**
     * Enables or disable system announcement
     * @param available true to enable system announcement
     * @throws ProcessingException if an error occurred
     */
    @Callable(rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public void setAnnouncementAvailable (boolean available) throws ProcessingException
    {
        SystemAnnouncement systemAnnouncement = readValues();
        
        _save(available ? "on" : "off", null, null, systemAnnouncement.getMessages());
    }
    
    /**
     * Schedule a system announcement
     * @param startDateStr the planned start date. Can be null for no start date
     * @param endDateStr the planned end date. Can be null for no end date
     * @throws ProcessingException if an error occurred
     */
    @Callable(rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public void scheduleAnnouncement(String startDateStr, String endDateStr) throws ProcessingException
    {
        // Parsing will throw an exception if string is not valid
        // preventing the saving of bogus values
        ZonedDateTime startDate = DateUtils.parseZonedDateTime(startDateStr);
        ZonedDateTime endDate = DateUtils.parseZonedDateTime(endDateStr);
        
        SystemAnnouncement systemAnnouncement = readValues();
        
        _save("scheduled", startDate, endDate, systemAnnouncement.getMessages());
    }
    
    /**
     * Add or edit a system announcement
     * @param language the language typed in by the user or "*" if modifying the default message
     * @param message the message to add nor edit
     * @param override true to override the existing value if exists
     * @return the result map
     * @throws Exception if an exception occurs
     */
    @Callable(rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public Map<String, Object> editAnnouncement(String language, String message, boolean override) throws Exception
    {
        Map<String, Object> result = new HashMap<> ();
        
        SystemAnnouncement systemAnnouncement = readValues();
        
        Map<String, String> messages = systemAnnouncement.getMessages();
        if (messages.containsKey(language) && !override)
        {
            result.put("already-exists", true);
            return result;
        }
        
        // Add or edit message
        messages.put(language, message);
        
        _save(systemAnnouncement.getState(), systemAnnouncement.getStartDate(), systemAnnouncement.getEndDate(), messages);
        
        return result;
    }
    
    /**
     * Delete a announcement
     * @param language the language of the announcement to delete
     * @throws ProcessingException if an exception occurs
     * @return an empty map
     */
    @Callable(rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public Map deleteAnnouncement(String language) throws ProcessingException
    {
        Map<String, Object> result = new HashMap<> ();
        
        SystemAnnouncement systemAnnouncement = readValues();
        
        Map<String, String> messages = systemAnnouncement.getMessages();
        if (messages.containsKey(language))
        {
            messages.remove(language);
            
            _save(systemAnnouncement.getState(), systemAnnouncement.getStartDate(), systemAnnouncement.getEndDate(), messages);
        }
        
        return result;
    }
    
    private File _getSystemFile()
    {
        return FileUtils.getFile(RuntimeConfig.getInstance().getAmetysHome(), AmetysHomeHelper.AMETYS_HOME_ADMINISTRATOR_DIR, ADMINISTRATOR_SYSTEM_FILENAME);
    }
    
    /**
     * Saves the system announcement's values
     * @param state true to enable system announcement
     * @param messages the messages
     * @throws ProcessingException if an error ocurred
     */
    private void _save (String state, ZonedDateTime startDate, ZonedDateTime endDate, Map<String, String> messages) throws ProcessingException
    {
        File systemFile = _getSystemFile();
        
        try
        {
            // Create file if not exists
            if (!systemFile.exists())
            {
                systemFile.getParentFile().mkdirs();
                systemFile.createNewFile();
            }
            
            // create a transformer for saving sax into a file
            TransformerHandler th = ((SAXTransformerFactory) TransformerFactory.newInstance()).newTransformerHandler();

            // create the result where to write
            try (OutputStream os = new FileOutputStream(systemFile))
            {
                StreamResult sResult = new StreamResult(os);
                th.setResult(sResult);
    
                // create the format of result
                Properties format = new Properties();
                format.put(OutputKeys.METHOD, "xml");
                format.put(OutputKeys.INDENT, "yes");
                format.put(OutputKeys.ENCODING, "UTF-8");
                th.getTransformer().setOutputProperties(format);
    
                // Send SAX events
                th.startDocument();
    
                AttributesImpl announcementsAttrs = new AttributesImpl();
                announcementsAttrs.addAttribute("", "state", "state", "CDATA", state);
                if (startDate != null)
                {
                    announcementsAttrs.addAttribute("", "start-date", "start-date", "CDATA", DateUtils.zonedDateTimeToString(startDate));
                }
                if (endDate != null)
                {
                    announcementsAttrs.addAttribute("", "end-date", "end-date", "CDATA", DateUtils.zonedDateTimeToString(endDate));
                }
                
                XMLUtils.startElement(th, "announcements", announcementsAttrs);
                
                for (String id : messages.keySet())
                {
                    AttributesImpl announcementAttrs = new AttributesImpl();
                    if (!"*".equals(id))
                    {
                        announcementAttrs.addAttribute("", "lang", "lang", "CDATA", id);
                    }
                    
                    XMLUtils.createElement(th, "announcement", announcementAttrs, messages.get(id));
                }
                
                XMLUtils.endElement(th, "announcements");
                
                th.endDocument();
            }
        }
        catch (Exception e)
        {
            throw new ProcessingException("Unable to save system announcement values", e);
        }
        finally
        {
            // clear the cache
            _cacheManager.get(SYSTEM_ANNOUNCEMENT_CACHE).invalidateAll();
        }
    }
    
    /**
     * Tests if system announcements are active.
     * @return true if system announcements are active.
     */
    @Callable (rights = Callable.SKIP_BUILTIN_CHECK)
    public boolean isSystemAnnouncementAvailable()
    {
        SystemAnnouncement systemAnnouncement = readValues();
        return systemAnnouncement.isAvailable();
    }
    
    /**
     * Get the system announcement availability
     * @return a map with the state, start date and end date
     */
    public Map<String, Object> getSystemAnnouncementAvailability()
    {
        SystemAnnouncement announcement = readValues();
        // Use HashMap to be able to store null value
        Map<String, Object> result = new HashMap<>(4);
        result.put("state", announcement.getState());
        result.put("start-date", announcement.getStartDate());
        result.put("end-date", announcement.getEndDate());
        
        return result;
    }
    
    /**
     * Return the date of the last modification of the annonce
     * @return The date of the last modification or 0 if there is no announce file
     */
    public long getSystemAnnoucementLastModificationDate()
    {
        try
        {
            File systemFile = _getSystemFile();
            if (!systemFile.exists() || !systemFile.isFile())
            {
                return 0;
            }
            
            return systemFile.lastModified();
        }
        catch (Exception e)
        {
            throw new RuntimeException("Unable to get system announcements", e);
        }
    }

    /**
     * Returns the system announcement for the given language code, or for the default language code if there is no specified announcement for the given language code.<br>
     * Returns null if the system announcements are not activated.
     * @param languageCode the desired language code of the system announcement
     * @return the system announcement in the specified language code, or in the default language code, or null if announcements are not active.
     */
    public String getSystemAnnouncement(String languageCode)
    {
        SystemAnnouncement systemAnnouncement = readValues();
        
        if (!systemAnnouncement.isAvailable())
        {
            return null;
        }
        
        Map<String, String> messages = systemAnnouncement.getMessages();
        
        String announcement = null;
        if (messages.containsKey(languageCode))
        {
            announcement = messages.get(languageCode);
        }
        
        if (StringUtils.isEmpty(announcement))
        {
            String defaultAnnouncement = messages.containsKey("*") ? messages.get("*") : null;
            if (StringUtils.isEmpty(defaultAnnouncement))
            {
                throw new IllegalStateException("There must be a default announcement.");
            }
            
            return defaultAnnouncement;
        }
        
        return announcement;
    }
    
    /**
     * Read the system announcement's values
     * @return The system announcement values;
     */
    public SystemAnnouncement readValues ()
    {
        Cache<String, SystemAnnouncement> cache = _cacheManager.get(SYSTEM_ANNOUNCEMENT_CACHE);
        return cache.get(SYSTEM_ANNOUNCEMENT_CACHE_KEY, str -> _readValues());
    }
    
    private SystemAnnouncement _readValues()
    {
        SystemAnnouncement announcement = new SystemAnnouncement();
        
        try
        {
            File systemFile = _getSystemFile();
            if (!systemFile.exists() || !systemFile.isFile())
            {
                _setDefaultValues();
            }
            
            Configuration configuration;
            try (InputStream is = new FileInputStream(systemFile))
            {
                configuration = new DefaultConfigurationBuilder().build(is);
            }
            
            // State
            String state = configuration.getAttribute("state", "off");
            announcement.setState(state);
            
            String startDate = configuration.getAttribute("start-date", null);
            if (startDate != null)
            {
                announcement.setStartDate(DateUtils.parseZonedDateTime(startDate));
            }
            
            String endDate = configuration.getAttribute("end-date", null);
            if (endDate != null)
            {
                announcement.setEndDate(DateUtils.parseZonedDateTime(endDate));
            }
            
            // Announcements
            for (Configuration announcementConfiguration : configuration.getChildren("announcement"))
            {
                String lang = announcementConfiguration.getAttribute("lang", "*");
                String message = announcementConfiguration.getValue();
                
                announcement.addMessage(lang, message);
            }
            
            return announcement;
        }
        catch (Exception e)
        {
            throw new RuntimeException("Unable to get system announcements", e);
        }
    }
    
    private void _setDefaultValues () throws ProcessingException
    {
        Map objectModel = ContextHelper.getObjectModel(_context);
        Locale locale = org.apache.cocoon.i18n.I18nUtils.findLocale(objectModel, "locale", null, Locale.getDefault(), true);
        String defaultMessage = _i18nUtils.translate(new I18nizableText("plugin.admin", "PLUGINS_ADMIN_SYSTEM_DEFAULTMESSAGE"), locale.getLanguage());

        Map<String, String> messages = new HashMap<> ();
        messages.put("*", defaultMessage);
        
        _save("off", null, null, messages);
    }
    
    /**
     * Class representing the system announcement file
     */
    public static class SystemAnnouncement
    {
        private String _state;
        private Map<String, String> _messages;
        private ZonedDateTime _startDate;
        private ZonedDateTime _endDate;
        
        /**
         * Constructor
         */
        public SystemAnnouncement()
        {
            _state = "off";
            _startDate = null;
            _endDate = null;
            _messages = new HashMap<>();
        }
        
        /**
         * Is the system announcement available ?
         * @return true if the system announcement is available, false otherwise
         */
        public boolean isAvailable()
        {
            return StringUtils.equals(_state, "on")
                || StringUtils.equals(_state, "scheduled")
                    && (_startDate == null || ZonedDateTime.now().isAfter(_startDate))
                    && (_endDate == null || ZonedDateTime.now().isBefore(_endDate));
        }
        
        /**
         * Get the messages by language
         * @return the messages by languaga
         */
        public Map<String, String> getMessages ()
        {
            return _messages;
        }
        
        /**
         * Set the state of the system announcement
         * @param state 'on' to set the enable system announcement,
         * 'scheduled' to enable it base on the start and end date
         * disabled otherwise
         */
        public void setState (String state)
        {
            _state = state;
        }
        
        /**
         * Get the state
         * @return "on", "off", "scheduled"
         */
        public String getState()
        {
            return _state;
        }
        
        /**
         * Set the start date for scheduled announcement
         * @param startDate the start date or null
         */
        public void setStartDate(ZonedDateTime startDate)
        {
            _startDate = startDate;
        }
        
        /**
         * Get the start date for scheduled announcement
         * @return the start date or null
         */
        public ZonedDateTime getStartDate()
        {
            return _startDate;
        }
        
        /**
         * Set the end date for scheduled announcement
         * @param endDate the end date or null
         */
        public void setEndDate(ZonedDateTime endDate)
        {
            _endDate = endDate;
        }
        
        /**
         * Get the end date for scheduled announcement
         * @return the end date or null
         */
        public ZonedDateTime getEndDate()
        {
            return _endDate;
        }
        
        /**
         * Add a message to the list of announcements
         * @param lang the language of the message
         * @param message the message itself
         */
        public void addMessage (String lang, String message)
        {
            _messages.put(lang, message);
        }
        
    }
}