package fr.ifremer.adagio.synchro.dao;

/*
 * #%L
 * SIH-Adagio :: Synchronization
 * $Id:$
 * $HeadURL:$
 * %%
 * Copyright (C) 2012 - 2014 Ifremer
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * #L%
 */

import java.io.Closeable;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

import fr.ifremer.adagio.synchro.meta.SynchroTableMetadata;
import fr.ifremer.adagio.synchro.service.SynchroPendingOperationBuffer;

public interface SynchroTableDao extends Closeable {

    Connection getConnection();

    SynchroTableMetadata getTable();

    void setPendingOperationBuffer(SynchroPendingOperationBuffer pendingChangesBuffer);

    SynchroPendingOperationBuffer getPendingOperationBuffer();

    /**
     * Obtains the max update date found in table's rows
     * 
     * @return
     * @throws SQLException
     */
    Timestamp getLastUpdateDate() throws SQLException;

    /**
     * Count the number of rows in the table
     * 
     * @return
     * @throws SQLException
     */
    long count() throws SQLException;

    /**
     * Count the number of rows updated since the given date
     * 
     * @param fromDate
     * @return
     * @throws SQLException
     */
    long countDataToUpdate(Date fromDate) throws SQLException;

    /**
     * Retrieve a id by a remote id. Only used for data synchronization (not used in referential synchronization)
     * 
     * @param tableName
     * @param remoteId
     * @return the local id, or null if remote_id not found
     */
    Integer getIdFromRemoteId(String tableName, Integer remoteId) throws SQLException;

    /**
     * Obtains existing remoteIds
     * 
     * @return
     * @throws SQLException
     */
    Map<Integer, Integer> getExistingRemoteIdsMap() throws SQLException;

    /**
     * Getting all row depending of parent FK values
     * 
     * @param fkColumnName
     *            the FK column name
     * @param fkValues
     *            values of the FK columns
     * @return
     * @throws SQLException
     */
    ResultSet getDataByFk(String fkColumnName, Set<Integer> fkValues) throws SQLException;

    /**
     * Obtains all data updated since the given date (or all data if the given date is null
     * 
     * @param fromDate
     * @return A Resulset with expected data.
     * @throws SQLException
     */
    ResultSet getDataToUpdate(Date fromDate) throws SQLException;

    /**
     * Obtains all primary keys of a table.
     * If more than one key in tha table, use a serialization {@link SynchroTableMetadata#toPkStr}
     * 
     * @return
     * @throws SQLException
     */
    Set<String> getExistingPrimaryKeys() throws SQLException;

    /**
     * Obtains a row, using values of each PK
     * 
     * @param pk
     *            values of PK column
     * @return the existing row in the table
     * @throws SQLException
     */
    Object[] findByPk(List<Object> pk) throws SQLException;

    /**
     * Obtains a PK from the current ResultSet's row
     * 
     * @param incomingData
     * @param tableBuffer
     * @return
     * @throws SQLException
     */
    List<Object> getPk(ResultSet incomingData) throws SQLException;

    /**
     * Delete all rows of a table
     * 
     * @throws SQLException
     */
    void deleteAll() throws SQLException;

    /**
     * Insert into a table the current row of the given {@link ResultSet}
     * 
     * @param pk
     *            the PK of the current row (only need for logging)
     * @param incomingData
     *            a {@link ResultSet} with a row ready to be read ({@link ResultSet#next()} should have been call
     *            before)
     * @throws SQLException
     */
    void executeInsert(ResultSet incomingData) throws SQLException;

    /**
     * Insert into a table the current row of the given incoming data
     * <p/>
     * Same as {@link #executeInsert(List,ResultSet)}, but using a array instead of a ResultSet.
     * 
     * @param incomingData
     *            a array of object
     * @throws SQLException
     */
    void executeInsert(Object[] row) throws SQLException;

    Integer executeInsertAndReturnId(ResultSet incomingData) throws SQLException;

    /**
     * Update one table's row, using the current row of the given {@link ResultSet}
     * 
     * @param pk
     *            the PK of the row to update
     * @param incomingData
     *            a {@link ResultSet} with a row ready to be read ({@link ResultSet#next()} should have been call
     *            before)
     * @throws SQLException
     */
    void executeUpdate(List<Object> pk, ResultSet incomingData) throws SQLException;

    /**
     * Update one table's row, using the current row of the given array of values
     * <p/>
     * Same as {@link #executeUpdate(List,ResultSet)}, but using a array instead of a ResultSet.
     * 
     * @param pk
     *            the PK of the row to update
     * @param row
     *            a array of object
     * @throws SQLException
     */
    void executeUpdate(List<Object> pk, Object[] row) throws SQLException;

    /**
     * Flush all pending updates (i.e. pending batch statement)
     * 
     * @throws SQLException
     */
    void flush() throws SQLException;

    /**
     * Obtains the number of updated rows
     * 
     * @return the number of updated rows
     */
    int getUpdateCount();

    /**
     * Obtains the number of inserted rows
     * 
     * @return the number of inserted rows
     */
    int getInsertCount();

}