package fr.ifremer.adagio.synchro.intercept;
   
   /*
    * #%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.sql.SQLException;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang3.StringUtils;
  import org.hibernate.tool.hbm2ddl.TableMetadata;
  
  import com.google.common.base.Preconditions;
  
  import fr.ifremer.adagio.synchro.dao.SynchroTableDao;
  import fr.ifremer.adagio.synchro.meta.SynchroDatabaseMetadata;
  import fr.ifremer.adagio.synchro.meta.SynchroJoinMetadata;
  import fr.ifremer.adagio.synchro.meta.SynchroTableMetadata;
  import fr.ifremer.adagio.synchro.service.SynchroContext;
  
  public class SynchroInterceptorBase implements SynchroInterceptorChain {
  	private SynchroInterceptor next;
  
  	private SynchroContext context;
  
  	public SynchroInterceptorBase() {
  		this.next = null;
  		this.context = null;
  	}
  
  	public SynchroInterceptorBase(SynchroInterceptor next) {
  		this.next = next;
  		this.context = null;
  	}
  
  	public boolean apply(SynchroDatabaseMetadata meta, TableMetadata table) {
  		return false;
  	}
  
  	@Override
  	public void setNext(SynchroInterceptor next) {
  		this.next = next;
  	}
  
  	public SynchroInterceptor getNext() {
  		return this.next;
  	}
  
  	@Override
  	public final void onRead(Object[] data, SynchroTableDao dao) throws SQLException {
  		doOnRead(data, dao);
  
  		if (next != null) {
  			next.onRead(data, dao);
  		}
  	}
  
  	@Override
  	public final void onWrite(Object[] data, SynchroTableDao dao, SynchroWriteBuffer buffer) throws SQLException {
  		doOnWrite(data, dao, buffer);
  
  		if (next != null) {
  			next.onWrite(data, dao, buffer);
  		}
  	}
  
  	@Override
  	public Map<List<Object>, Object[]> transformExtraLocalData(
  			SynchroTableDao localDao, SynchroTableDao remoteDao,
  			Map<List<Object>, Object[]> extraRows) throws SQLException {
  		Map<List<Object>, Object[]> result = doTransformExtraLocalData(localDao, remoteDao, extraRows);
  
  		if (next != null) {
  			result = next.transformExtraLocalData(localDao, remoteDao, result);
  		}
  		return result;
  	}
  
  	@Override
 	public final String onCreateSelectQuery(SynchroTableMetadata table, String queryName, String sql) {
 		String newSql = doCreateSelectQuery(table, queryName, sql);
 
 		if (next != null) {
 			newSql = next.onCreateSelectQuery(
 					table,
 					queryName,
 					newSql != null ? newSql : sql);
 		}
 		return newSql;
 	}
 
 	public final void onTableLoad(SynchroTableMetadata table) {
 		doTableLoad(table);
 		if (next != null) {
 			next.onTableLoad(table);
 		}
 	}
 
 	public final void onJoinLoad(SynchroTableMetadata table, SynchroJoinMetadata join) {
 		doJoinLoad(table, join);
 		if (next != null) {
 			next.onJoinLoad(table, join);
 		}
 	}
 
 	@Override
 	public boolean enableOnRead() {
 		return false;
 	}
 
 	@Override
 	public boolean enableOnWrite() {
 		return false;
 	}
 
 	@Override
 	public void setContext(SynchroContext context) {
 		this.context = context;
 	}
 
 	protected SynchroContext getContext() {
 		return this.context;
 	}
 
 	/* -- protected method -- */
 
 	protected void doTableLoad(SynchroTableMetadata table) {
 	}
 
 	protected void doJoinLoad(SynchroTableMetadata table, SynchroJoinMetadata join) {
 	}
 
 	protected String doCreateSelectQuery(SynchroTableMetadata table, String queryName, String sql) {
 		String[] clauses = sql.split("(FROM)|(WHERE)");
 		Preconditions.checkArgument(
 				clauses.length == 2 || clauses.length == 3,
 				String.format("Bad sql query: [%s]. Expected: SELECT <...> FROM <...> WHERE <...>", sql));
 		String selectClause = clauses[0];
 		String fromClause = clauses[1];
 		String whereClause = clauses.length == 3 ? clauses[2] : null;
 		return doCreateSelectQuery(table, selectClause, fromClause, whereClause, queryName);
 	}
 
 	/**
 	 * Default implementation, that return the same SQL query.
 	 * This method should be override by subclasses
 	 * 
 	 * @param table
 	 * @param selectClause
 	 * @param fromClause
 	 * @param whereClause
 	 * @param queryName
 	 * @return
 	 */
 	protected String doCreateSelectQuery(SynchroTableMetadata table,
 			String selectClause,
 			String fromClause,
 			String whereClause,
 			String queryName) {
 		StringBuilder sb = new StringBuilder(selectClause).append(" FROM ").append(fromClause);
 		if (StringUtils.isNotBlank(whereClause)) {
 			sb.append(" WHERE ").append(whereClause);
 		}
 		return sb.toString();
 	}
 
 	protected void doOnRead(Object[] data, SynchroTableDao dao) throws SQLException {
 
 	}
 
 	protected void doOnWrite(Object[] data, SynchroTableDao dao, SynchroWriteBuffer buffer) throws SQLException {
 
 	}
 
 	protected Map<List<Object>, Object[]> doTransformExtraLocalData(
 			SynchroTableDao localDao, SynchroTableDao remoteDao,
 			Map<List<Object>, Object[]> extraRows) throws SQLException {
 		return extraRows;
 	}
 
 }