/**
 * The contents of this file are subject to the license and copyright
 * detailed in the LICENSE and NOTICE files at the root of the source
 * tree and available online at
 *
 * http://www.dspace.org/license/
 */
package org.dspace.content;

import org.apache.commons.collections.CollectionUtils;
import org.apache.log4j.Logger;
import org.dspace.authorize.AuthorizeException;
import org.dspace.authorize.service.AuthorizeService;
import org.dspace.content.dao.BitstreamFormatDAO;
import org.dspace.content.service.BitstreamFormatService;
import org.dspace.core.Context;
import org.dspace.core.LogManager;
import org.springframework.beans.factory.annotation.Autowired;

import java.sql.SQLException;
import java.util.Collections;
import java.util.List;

/**
 * Service implementation for the BitstreamFormat object.
 * This class is responsible for all business logic calls for the BitstreamFormat object and is autowired by spring.
 * This class should never be accessed directly.
 *
 * @author kevinvandevelde at atmire.com
 */
public class BitstreamFormatServiceImpl implements BitstreamFormatService {

    /** log4j logger */
    private static Logger log = Logger.getLogger(BitstreamFormat.class);

    @Autowired(required = true)
    protected BitstreamFormatDAO bitstreamFormatDAO;

    @Autowired(required = true)
    protected AuthorizeService authorizeService;

    protected BitstreamFormatServiceImpl()
    {

    }

    /** translate support-level ID to string.  MUST keep this table in sync
     *  with support level definitions above.
     */
    protected final String supportLevelText[] =
        { "UNKNOWN", "KNOWN", "SUPPORTED" };


    /**
     * Get a bitstream format from the database.
     *
     * @param context
     *            DSpace context object
     * @param id
     *            ID of the bitstream format
     *
     * @return the bitstream format, or null if the ID is invalid.
     * @throws SQLException if database error
     */
    @Override
    public BitstreamFormat find(Context context, int id)
            throws SQLException
    {
        BitstreamFormat bitstreamFormat = bitstreamFormatDAO.findByID(context, BitstreamFormat.class, id);

        if (bitstreamFormat == null)
        {
            if (log.isDebugEnabled())
            {
                log.debug(LogManager.getHeader(context,
                        "find_bitstream_format",
                        "not_found,bitstream_format_id=" + id));
            }

            return null;
        }

        // not null, return format object
        if (log.isDebugEnabled())
        {
            log.debug(LogManager.getHeader(context, "find_bitstream_format",
                    "bitstream_format_id=" + id));
        }

        return bitstreamFormat;
    }

    @Override
    public BitstreamFormat findByMIMEType(Context context, String mimeType) throws SQLException {
        return bitstreamFormatDAO.findByMIMEType(context, mimeType, false);
    }

    @Override
    public BitstreamFormat findByShortDescription(Context context, String desc) throws SQLException{
        return bitstreamFormatDAO.findByShortDescription(context, desc);
    }

    @Override
    public BitstreamFormat findUnknown(Context context) throws SQLException {
        BitstreamFormat bf = findByShortDescription(context, "Unknown");

        if (bf == null)
        {
            throw new IllegalStateException(
                    "No `Unknown' bitstream format in registry");
        }

        return bf;
    }

    @Override
    public List<BitstreamFormat> findAll(Context context) throws SQLException {
        return bitstreamFormatDAO.findAll(context, BitstreamFormat.class);
    }

    @Override
    public List<BitstreamFormat> findNonInternal(Context context) throws SQLException {
        return bitstreamFormatDAO.findNonInternal(context);
    }

    @Override
    public BitstreamFormat create(Context context) throws SQLException, AuthorizeException {
                // Check authorisation - only administrators can create new formats
        if (!authorizeService.isAdmin(context))
        {
            throw new AuthorizeException(
                    "Only administrators can create bitstream formats");
        }

        // Create a table row
        BitstreamFormat bitstreamFormat = bitstreamFormatDAO.create(context, new BitstreamFormat());


        log.info(LogManager.getHeader(context, "create_bitstream_format",
                "bitstream_format_id="
                        + bitstreamFormat.getID()));

        return bitstreamFormat;
    }

    @Override
    public void setShortDescription(Context context, BitstreamFormat bitstreamFormat, String shortDescription) throws SQLException {
                // You can not reset the unknown's registry's name
        BitstreamFormat unknown = null;
		try {
			unknown = findUnknown(context);
		} catch (IllegalStateException e) {
			// No short_description='Unknown' found in bitstreamformatregistry
			// table. On first load of registries this is expected because it
			// hasn't been inserted yet! So, catch but ignore this runtime
			// exception thrown by method findUnknown.
		}

		// If the exception was thrown, unknown will == null so goahead and
		// load s. If not, check that the unknown's registry's name is not
		// being reset.
		if (unknown == null || unknown.getID() != bitstreamFormat.getID()) {
            bitstreamFormat.setShortDescriptionInternal(shortDescription);
		}
    }

    @Override
    public String getSupportLevelText(BitstreamFormat bitstreamFormat) {
        return supportLevelText[bitstreamFormat.getSupportLevel()];
    }

    @Override
    public void setSupportLevel(BitstreamFormat bitstreamFormat, int supportLevel) {
                // Sanity check
        if ((supportLevel < 0) || (supportLevel > 2))
        {
            throw new IllegalArgumentException("Invalid support level");
        }

        bitstreamFormat.setSupportLevelInternal(supportLevel);
    }

    @Override
    public void update(Context context, BitstreamFormat bitstreamFormat) throws SQLException, AuthorizeException {
        update(context, Collections.singletonList(bitstreamFormat));
    }

    @Override
    public void update(Context context, List<BitstreamFormat> bitstreamFormats) throws SQLException, AuthorizeException {
        if(CollectionUtils.isNotEmpty(bitstreamFormats)) {
            // Check authorisation - only administrators can change formats
            if (!authorizeService.isAdmin(context)) {
                throw new AuthorizeException(
                        "Only administrators can modify bitstream formats");
            }

            for (BitstreamFormat bitstreamFormat : bitstreamFormats) {
                log.info(LogManager.getHeader(context, "update_bitstream_format",
                        "bitstream_format_id=" + bitstreamFormat.getID()));

                bitstreamFormatDAO.save(context, bitstreamFormat);
            }
        }
    }

    @Override
    public void delete(Context context, BitstreamFormat bitstreamFormat) throws SQLException, AuthorizeException {
                // Check authorisation - only administrators can delete formats
        if (!authorizeService.isAdmin(context))
        {
            throw new AuthorizeException(
                    "Only administrators can delete bitstream formats");
        }

        // Find "unknown" type
        BitstreamFormat unknown = findUnknown(context);

        if (unknown.getID() == bitstreamFormat.getID())
        {
            throw new IllegalArgumentException("The Unknown bitstream format may not be deleted.");
        }

        // Set bitstreams with this format to "unknown"
        int numberChanged = bitstreamFormatDAO.updateRemovedBitstreamFormat(context, bitstreamFormat, unknown);

        // Delete this format from database
        bitstreamFormatDAO.delete(context, bitstreamFormat);

        log.info(LogManager.getHeader(context, "delete_bitstream_format",
                "bitstream_format_id=" + bitstreamFormat.getID() + ",bitstreams_changed="
                        + numberChanged));
    }

    @Override
    public int getSupportLevelID(String supportLevel) {
        for (int i = 0; i < supportLevelText.length; i++)
        {
            if (supportLevelText[i].equals(supportLevel))
            {
                return i;
            }
        }

        return -1;
    }

    @Override
    public BitstreamFormat guessFormat(Context context, Bitstream bitstream) throws SQLException {
        String filename = bitstream.getName();
        // FIXME: Just setting format to first guess
        // For now just get the file name

        // Gracefully handle the null case
        if (filename == null) {
            return null;
        }

        filename = filename.toLowerCase();

        // This isn't rocket science. We just get the name of the
        // bitstream, get the extension, and see if we know the type.
        String extension = filename;
        int lastDot = filename.lastIndexOf('.');

        if (lastDot != -1) {
            extension = filename.substring(lastDot + 1);
        }

        // If the last character was a dot, then extension will now be
        // an empty string. If this is the case, we don't know what
        // file type it is.
        if (extension.equals("")) {
            return null;
        }

        List<BitstreamFormat> bitstreamFormats = bitstreamFormatDAO.findByFileExtension(context, extension);

        if(CollectionUtils.isNotEmpty(bitstreamFormats))
        {
            return bitstreamFormats.get(0);
        }
        return null;
    }
}