/*
 *  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.plugins.sms.action;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.acting.ServiceableAction;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.servlet.multipart.Part;
import org.apache.cocoon.servlet.multipart.PartOnDisk;
import org.apache.cocoon.servlet.multipart.RejectedPart;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.input.BOMInputStream;

import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.sms.SMSHelper;
import org.ametys.plugins.sms.dao.SubscriberDAO;

/**
 * Action importing subscribers from a CSV file supposedly containing one valid number per line
 */
public class ImportSMSListSubscribersAction extends ServiceableAction
{
    private static final String[] __ALLOWED_EXTENSIONS = new String[] {"txt", "csv"};
    
    /** The subscribers DAO. */
    private SubscriberDAO _subscriberDAO;
    
    /** The Ametys object resolver */
    private AmetysObjectResolver _ametysObjectResolver;

    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        super.service(smanager);
        _subscriberDAO = (SubscriberDAO) smanager.lookup(SubscriberDAO.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
    }
    
    @Override
    public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, String source, Parameters parameters) throws Exception
    {
        Map<String, String> result = new HashMap<>();

        Request request = ObjectModelHelper.getRequest(objectModel);

        String smsListId = request.getParameter("smsListId");
        boolean cleanTable = "true".equals(request.getParameter("cleanSubscribers"));
        
        Part part = (Part) request.get("importFile");
        if (part instanceof RejectedPart)
        {
            return Collections.singletonMap("error", "rejected-file");
        }
        
        PartOnDisk uploadedFilePart = (PartOnDisk) part;
        File uploadedFile = (uploadedFilePart != null) ? uploadedFilePart.getFile() : null;
        String filename = (uploadedFilePart != null) ? uploadedFilePart.getFileName().toLowerCase() : null;
        
        if (!FilenameUtils.isExtension(filename, __ALLOWED_EXTENSIONS))
        {
            return Collections.singletonMap("error", "invalid-extension");
        }
        
        // Test if the sms list exists.
        if (!_ametysObjectResolver.hasAmetysObjectForId(smsListId))
        {
            return Collections.singletonMap("error", "unknown-list");
        }
        
        Collection<String> phoneNumbers = null;
        try (FileInputStream fileIS = new FileInputStream(uploadedFile);
             BOMInputStream bomIS = new BOMInputStream(fileIS);)
        {
            // Extract the phone numbers from the file.
            phoneNumbers = _getPhoneNumbers(bomIS, result);
        }
        
        if (!phoneNumbers.isEmpty())
        {
            // Empty the broadcasting list subscribers if needed.
            if (cleanTable)
            {
                _subscriberDAO.deleteAllNumbers(smsListId);
            }
            
            // Insert the phone numbers.
            _insertSubscribers(phoneNumbers, smsListId, result);
        }
        else
        {
            result.put("subscribedCount", "0");
            result.put("existingCount", "0");
            result.put("errorCount", "0");
        }
        
        result.put("success", "true");
        result.put("smsListId", smsListId);
        
        return result;
    }
    
    /**
     * Extract the phone numbers from the file.
     * @param bomIS the BOM input stream 
     * @param result the result map
     * @return the collection of phone numbers.
     * @throws IOException if an error occurs reading the file.
     */
    private Set<String> _getPhoneNumbers(BOMInputStream bomIS, Map<String, String> result) throws IOException
    {
        Set<String> phoneNumbers = new HashSet<>();
        int errorCount = 0;
        
        for (String phoneNumber : IOUtils.readLines(bomIS))
        {
            // We check if the phone number is correct
            String transformedNumber = phoneNumber.trim();           
            transformedNumber = SMSHelper.transformPhoneNumber(transformedNumber);
            
            if (!SMSHelper.checkPhoneNumber(transformedNumber) && !SMSHelper.PHONE_NUMBER_INTERNATIONAL_VALIDATOR.matcher(transformedNumber).matches())
            {   
                getLogger().warn("Import subscribers phone number: '" + phoneNumber + "' is not a valid phone number; it will be ignored");
                errorCount++;
            }
            else
            {
                phoneNumbers.add(transformedNumber);
            }
        }
        result.put("errorCount", Integer.toString(errorCount));
        return phoneNumbers;
    }
    
    /**
     * Insert subscribers in the broadcasting list
     * @param phoneNumbers the list of phone numbers to insert
     * @param smsListId the id of the sms list 
     * @param result the server call result 
     */
    private void _insertSubscribers(Collection<String> phoneNumbers, String smsListId, Map<String, String> result)
    {
        int subscribedCount = 0;
        int existingCount = 0;
        int errorCount = Integer.parseInt(result.get("errorCount"));
        
        for (String phoneNumber : phoneNumbers)
        {
            try
            {
                if (_subscriberDAO.numberAlreadyExists(phoneNumber, smsListId))
                {
                    existingCount++;
                }
                else
                {
                    _subscriberDAO.insertNumber(phoneNumber, smsListId);
                    
                    if (getLogger().isInfoEnabled())
                    {
                        getLogger().info("The user with phoneNumber '" + phoneNumber + "' subscribed to the list '" + smsListId + "'.");
                    }
                    
                    subscribedCount++;
                }
            }
            catch (Exception e)
            {
                getLogger().error("Impossible to add as a subscriber the phoneNumber " + phoneNumber + " in list '" + smsListId + "'.", e);
                errorCount++;
            }
        }
        
        result.put("subscribedCount", Integer.toString(subscribedCount));
        result.put("existingCount", Integer.toString(existingCount));
        result.put("errorCount", Integer.toString(errorCount));
    }
}