/*
 *  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.core.impl.datasource;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.sql.Blob;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.commons.lang3.StringUtils;

import org.ametys.core.datasource.dbtype.SQLDatabaseType;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * Default implementation for a {@link SQLDatabaseType}.
 */
public class StaticSQLDatabaseType extends AbstractLogEnabled implements Configurable, SQLDatabaseType, PluginAware
{
    /** The id of the database type */
    protected String _id;
    
    /** The label of the database type */
    protected I18nizableText _label;

    /** The driver of the database type */
    protected String _driver;
    
    /** The url template for this database type */
    protected String _template;
    
    /** The plugin's name */
    protected String _pluginName;
    
    /** The SQL query to validate the connection is still alive */
    protected String _validationQuery;
    
    /** The driver not found message */
    protected I18nizableText _driverNotFoundMessage;

    /** The template to escape the table name. Must contain {tableName} */
    protected String _languageEscapeTableNameTemplate;
    /** The template to limit the query to a limit/offset. Must contain {query} {limit} and {offset}*/
    protected String _languageLimitQueryTemplate;
    
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
        _id = id;
    }
    
    public void configure(Configuration configuration) throws ConfigurationException
    {
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Configuring database type with id '" + _id  + "'");
        }
        
        _label = I18nizableText.parseI18nizableText(configuration.getChild("label"), "plugin." + _pluginName);
        _driver = configuration.getChild("driver").getValue();
        _driverNotFoundMessage = I18nizableText.parseI18nizableText(configuration.getChild("driver-not-found-message"), "plugin." + _pluginName); 
        _template = configuration.getChild("template").getValue("");
        _validationQuery = configuration.getChild("validation-query").getValue("SELECT 1");
        _languageEscapeTableNameTemplate = configuration.getChild("language").getChild("escape-table-name").getValue("{tableName}");
        _languageLimitQueryTemplate = configuration.getChild("language").getChild("limit-query").getValue("{query} LIMIT {limit} OFFSET {offset}");
    }
    
    public String getId()
    {
        return _id;
    }
    
    public I18nizableText getLabel() 
    {
        return _label;
    }
    
    public String getDriver() 
    {
        return _driver;
    }
    
    public String getTemplate()
    {
        return _template;
    }
    
    public String getValidationQuery()
    {
        return _validationQuery;
    }
    
    public I18nizableText getDriverNotFoundMessage()
    {
        return _driverNotFoundMessage;
    }
    
    public String languageEscapeTableName(String tableNameToEscape)
    {
        return StringUtils.replace(_languageEscapeTableNameTemplate, "{tableName}", tableNameToEscape);
    }
    
    public String languageLimitQuery(String queryToLimit, String limit, String offset)
    {
        return StringUtils.replace(StringUtils.replace(StringUtils.replace(_languageLimitQueryTemplate, "{query}", queryToLimit), "{limit}", limit), "{offset}", offset);
    }
    
    public InputStream getBlob(ResultSet resultSet, String columnName) throws SQLException
    {
        Blob commentBlob = resultSet.getBlob(columnName);
        return commentBlob != null ? commentBlob.getBinaryStream() : null;
    }
    
    public InputStream getBlob(ResultSet resultSet, int pos) throws SQLException
    {
        Blob commentBlob = resultSet.getBlob(pos);
        return commentBlob != null ? commentBlob.getBinaryStream() : null;
    }
    
    public void setBlob(PreparedStatement statement, int pos, String blob) throws SQLException, UnsupportedEncodingException
    {
        if (blob == null)
        {
            statement.setNull(pos, Types.BLOB);
        }
        else
        {
            byte[] bytes = blob.getBytes("UTF-8");
            setBlob(statement, pos, bytes);
        }
    }
    
    public void setBlob(PreparedStatement statement, int pos, byte[] bytes) throws SQLException
    {
        if (bytes == null)
        {
            statement.setNull(pos, Types.BLOB);
        }
        else
        {
            statement.setBlob(pos, new ByteArrayInputStream(bytes));
        }
    }

    public void setBlob(PreparedStatement statement, int pos, InputStream is, long length) throws SQLException
    {
        if (is == null)
        {
            statement.setNull(pos, Types.BLOB);
        }
        else
        {
            statement.setBlob(pos, is);
        }
    }
}