/*
 *  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.web.alias;

import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.jcr.RepositoryException;

import org.apache.avalon.framework.component.Component;
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.commons.lang.StringUtils;

import org.ametys.core.ui.Callable;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.web.alias.Alias.TargetType;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.site.SiteManager;

/**
 * Class managing {@link Alias} creation, modification, deletion and moving
 */
public class AliasDAO extends AbstractLogEnabled implements Component, Serviceable
{
    /** The component's role */
    public static final String ROLE = AliasDAO.class.getName();
    
    /** The PAGE pattern */
    public static final Pattern PAGE_PATTERN = Pattern.compile("/([^?]+)\\.html");
    /** The URL pattern */
    public static final Pattern URL_PATTERN = Pattern.compile("/.+");
    /** The URL pattern ... Copy of the regexp in Ametys.plugins.web.alias.AliasActions.js#_delayedInitialize */
    public static final Pattern TARGET_URL_PATTERN = Pattern.compile("(https?://|/).+");
    /** The alias default name */
    public static final String DEFAULT_ALIAS_NAME = "alias";
    
    /** The Ametys object resolver */
    private AmetysObjectResolver _ametysObjectResolver;
    /** The site manager */
    private SiteManager _siteManager;
    
    public void service(ServiceManager smanager) throws ServiceException
    {
        _ametysObjectResolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _siteManager = (SiteManager) smanager.lookup(SiteManager.ROLE);
    }
    
    /**
     * Get an alias
     * @param id the id of the alias to get
     * @return the JSON representation of the alias
     */
    @Callable
    public Map<String, Object> getAlias(String id)
    {
        DefaultAlias alias = _ametysObjectResolver.resolveById(id);
        return alias2Json(alias);
    }
    
    /**
     * Create an alias
     * @param type the type (page or url)
     * @param url the origin url
     * @param target the target url
     * @param siteName the site's name
     * @param dateStr the optional expiration date of the alias
     * @return a map
     */
    @Callable
    public Map<String, String> createAlias(String type, String url, String target, String siteName, String dateStr)
    {
        Map<String, String> result = new HashMap<>();
        TargetType targetType = TargetType.valueOf(type);
        
        // Check if the alias does not already exist
        if (_checkExistence(siteName, url))
        {
            result.put("msg", "already-exists");
            return result;
        }
        
        if (!isValidUrl(url))
        {
            result.put("msg", "invalid-url");
            return result;
        }
        
        if (TargetType.URL.equals(TargetType.valueOf(type)) && !isValidTargetUrl(target))
        {
            result.put("msg", "invalid-target-url");
            return result;
        }
        
        ModifiableTraversableAmetysObject rootNode = AliasHelper.getRootNode(_siteManager.getSite(siteName));
        
        String aliasName = AliasHelper.getAliasNextUniqueName(rootNode);
        
        DefaultAlias alias = rootNode.createChild(aliasName, "ametys:alias");
        alias.setUrl(url);
        alias.setTarget(target);
        alias.setType(targetType);
        alias.setCreationDate(new Date());
        if (StringUtils.isNotEmpty(dateStr))
        {
            Date date = DateUtils.parse(dateStr);
            alias.setExpirationDate(date);
        }
        
        rootNode.saveChanges();
        
        result.put("id", alias.getId());
        
        return result;
    }
    
    /**
     * Update an alias
     * @param id the id of the alias to update
     * @param type the type (page or url)
     * @param url the origin url
     * @param target the target url
     * @param siteName the site's name
     * @param dateStr the optional expiration date of the alias
     * @return a map
     */
    @Callable
    public Map<String, String> updateAlias(String id, String type, String url, String target, String siteName, String dateStr)
    {
        Map<String, String> result = new HashMap<>();
        
        // Check the alias does not already exist
        if (_checkExistence(id, siteName, url))
        {
            result.put("msg", "already-exists");
            return result;
        }
        
        if (!isValidUrl(url))
        {
            result.put("msg", "invalid-url");
            return result;
        }
        
        try
        {
            DefaultAlias alias = _ametysObjectResolver.resolveById(id);
            
            if (TargetType.URL.equals(alias.getType()) && !isValidTargetUrl(target))
            {
                result.put("msg", "invalid-target-url");
                return result;
            }
            
            alias.setUrl(url);
            alias.setTarget(target);
            if (StringUtils.isNotEmpty(dateStr))
            {
                Date date = DateUtils.parse(dateStr);
                alias.setExpirationDate(date);
            }
            else
            {
                alias.removeExpirationDate();
            }
            
            alias.saveChanges();
            
            result.put("id", alias.getId());
        }
        catch (UnknownAmetysObjectException e)
        {
            result.put("msg", "unknown-alias");
            getLogger().error("Unable to edit alias. The alias of id '" + id + " doesn't exist", e);
        }
        
        return result;
    }
    
    /**
     * Delete an alias
     * @param ids the list of ids of aliases to delete
     * @return a map
     */
    @Callable
    public Map<String, String> deleteAlias(List<String> ids)
    {
        Map<String, String> result = new HashMap<>();
        for (String id : ids)
        {
            try
            {
                DefaultAlias alias = _ametysObjectResolver.resolveById(id);
                ModifiableAmetysObject parent = alias.getParent();
                alias.remove(); 
                
                parent.saveChanges();
            }
            catch (UnknownAmetysObjectException e)
            {
                result.put("msg", "unknown-alias");
                getLogger().error("Unable to delete alias. The alias of id '" + id + " doesn't exist", e);
            }
        }
        
        return result;
    }
    
    /**
     * Move an alias
     * @param id the id of the alias to move
     * @param role the action to perform
     * @return an empty map
     * @throws RepositoryException if an error occurs
     */
    @Callable
    public Map<String, Object> moveAlias(String id, String role) throws RepositoryException
    {
        Map<String, Object> result = new HashMap<> ();
         
        DefaultAlias alias = _ametysObjectResolver.resolveById(id);
        
        if ("move-first".equals(role))
        {
            _moveFirst(alias);
        }
        else if ("move-up".equals(role))
        {
            _moveUp(alias);
        }
        else if ("move-down".equals(role))
        {
            _moveDown(alias);
        }
        else if ("move-last".equals(role))
        {
            _moveLast(alias);
        }
        
        return result;
    }
    
    
    /**
     * Move first.
     * @param alias the alias to move 
     * @throws RepositoryException if an errors occurs while moving
     */
    private void _moveFirst(DefaultAlias alias) throws RepositoryException
    {
        try (AmetysObjectIterable<AmetysObject>  children = ((TraversableAmetysObject) alias.getParent()).getChildren();)
        {
            // Resolve the link in the same session or the linkRoot.saveChanges() call below won't see the order changes.
            alias.orderBefore(((TraversableAmetysObject) alias.getParent()).getChildren().iterator().next());
            ((ModifiableAmetysObject) alias.getParent()).saveChanges();
        }
    }

    /**
     * Move down.
     * @param alias the alias to move 
     * @throws RepositoryException if an errors occurs while moving
     */
    private void _moveDown(DefaultAlias alias) throws RepositoryException
    {
        TraversableAmetysObject parentNode = alias.getParent();
        boolean iterate = true;

        try (AmetysObjectIterable<AmetysObject> siblings = parentNode.getChildren();)
        {
            Iterator<AmetysObject> it = siblings.iterator();
            while (it.hasNext() && iterate)
            {
                DefaultAlias sibling = (DefaultAlias) it.next();
                iterate = !sibling.getName().equals(alias.getName());
            }
            
            // Move the link after his next sibling: move the next sibling before the link to move.
            DefaultAlias nextLink = (DefaultAlias) it.next();
            nextLink.orderBefore(alias);
    
            alias.saveChanges();
        }
    }
    
    /**
     * Move up.
     * @param alias the alias to move
     * @throws RepositoryException if an errors occurs while moving
     */
    private void _moveUp(DefaultAlias alias) throws RepositoryException
    {
        TraversableAmetysObject parentNode = alias.getParent();
        DefaultAlias previousLink = null;

        try (AmetysObjectIterable<AmetysObject> siblings = parentNode.getChildren();)
        {
            Iterator<AmetysObject> it = siblings.iterator();
            while (it.hasNext())
            {
                DefaultAlias sibling = (DefaultAlias) it.next();
                if (sibling.getName().equals(alias.getName()))
                {
                    break;
                }
                
                previousLink = sibling;
            }
                
            // Move the link after his next sibling: move the next sibling before the link to move.
            alias.orderBefore(previousLink);
            alias.saveChanges();
        }
    }
    
    /**
     * Move last.
     * @param link the alias to move 
     * @throws RepositoryException if an errors occurs while moving
     */
    private void _moveLast(DefaultAlias link) throws RepositoryException
    {
        link.moveTo(link.getParent(), false);
        ((ModifiableAmetysObject) link.getParent()).saveChanges();
    }
    
    
    /**
     * Checks the existence of an alias with same URL
     * @param id the alias
     * @param siteName The site name
     * @param url The alias URL
     * @return true if an alias with the same URL exists
     */
    private boolean _checkExistence (String id, String siteName, String url)
    {
        String xpathQuery = AliasHelper.getXPath(siteName, url);

        try (AmetysObjectIterable<DefaultAlias> aliases = _ametysObjectResolver.query(xpathQuery);)
        {
            Iterator<DefaultAlias> it = aliases.iterator();
            while (it.hasNext())
            {
                DefaultAlias alias = it.next();
                if (!id.equals(alias.getId()))
                {
                    return true;
                }
            }
            return false;
        }
        catch (Exception e)
        {
            return false;
        }
    }
    
    /**
     * Checks the existence of an alias
     * @param siteName The site name
     * @param url The alias URL
     * @return true if an alias with the same URL exists
     */
    private boolean _checkExistence (String siteName, String url)
    {
        try
        {
            String xpathQuery = AliasHelper.getXPath(siteName, url);
            return _ametysObjectResolver.query(xpathQuery).iterator().hasNext();
        }
        catch (Exception e)
        {
            return false;
        }
    }
    
    /**
     * Validates the url 
     * @param url the url to check
     * @return true if the url is valid
     */
    private boolean isValidUrl (String url)
    {
        Matcher matcher = URL_PATTERN.matcher(url);
        return matcher.matches();
    }
    
    /**
     * Validates the url 
     * @param url the url to check
     * @return true if the url is valid
     */
    private boolean isValidTargetUrl (String url)
    {
        Matcher matcher = TARGET_URL_PATTERN.matcher(url);
        return matcher.matches();
    }
    
    /**
     * Represent an {@link Alias} in JSON
     * @param alias The alias 
     * @return the alias in JSON
     */
    public Map<String, Object> alias2Json (DefaultAlias alias) 
    {
        Map<String, Object> aliasJson = new HashMap<>();
        aliasJson.put("id", alias.getId());
        aliasJson.put("url", alias.getUrl());
        aliasJson.put("target", alias.getTarget());

        TargetType type = alias.getType();
        aliasJson.put("type", String.valueOf(type));
        
        String target = alias.getTarget();
        
        if (TargetType.PAGE.equals(type))
        {
            try
            {
                Page page = _ametysObjectResolver.resolveById(target);
                aliasJson.put("targetUrl", "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + ".html");
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().warn("Alias '" + alias.getUrl() + "' redirect to an unknown page of id '" + target + "'", e);
                aliasJson.put("targetUrl", "unknown");
            }
        }
        else
        {
            aliasJson.put("targetUrl", target);
        }
        
        aliasJson.put("createAt", DateUtils.dateToString(alias.getCreationDate()));

        Date expirationDate = alias.getExpirationDate();
        aliasJson.put("expirationDate", expirationDate != null ? DateUtils.dateToString(expirationDate) : "");
        
        if (expirationDate != null)
        {
            LocalDate localExpDate = expirationDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
            LocalDate now = LocalDate.now();
            
            aliasJson.put("expired", now.compareTo(localExpDate) > 0);
        }
        else
        {
            aliasJson.put("expired", false);
        }
        
        return aliasJson;
    }
}