package uk.ac.ebi.intenz.mapper;

 import java.sql.Connection;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.util.Date;

 import java.util.List;

 import java.util.Vector;

 import uk.ac.ebi.intenz.domain.constants.EventConstant;

 import uk.ac.ebi.intenz.domain.constants.Status;

 import uk.ac.ebi.intenz.domain.enzyme.EnzymeEntry;

 import uk.ac.ebi.intenz.domain.exceptions.DomainException;

 import uk.ac.ebi.intenz.domain.history.FutureEvent;

 import uk.ac.ebi.intenz.domain.history.HistoryGraph;

 import uk.ac.ebi.intenz.domain.history.HistoryNode;

 import uk.ac.ebi.intenz.domain.history.Timeout;

 /**

  * Maps future event information to the corresponding database tables.

  *

  * @author Michael Darsow

  * @version $Revision: 1.3 $ $Date: 2009/05/26 14:59:09 $

  */

 public class EnzymeFutureMapper extends EnzymeHistoryMapper {

   private static final String COLUMNS = "f.group_id, f.event_id, f.before_id, f.after_id, f.event_year, " +

           "f.event_note, f.event_class, f.status, f.timeout_id, " +

           "t.enzyme_id, t.start_date, t.due_date";

   public EnzymeFutureMapper() {

     super();

   }

   private String findStatement() {

     return "SELECT " + COLUMNS +

             " FROM future_events f, timeouts t" +

             " WHERE (before_id = ? OR after_id = ?) AND f.timeout_id = t.timeout_id";

   }

     @Override

   public HistoryGraph find(EnzymeEntry enzymeEntry, Connection con)

   throws SQLException, DomainException {

     if (enzymeEntry == null) throw new NullPointerException();

     HistoryNode currentNode = findNode(enzymeEntry, true, con);

     if (currentNode == null)

       return null;

     return new HistoryGraph(currentNode);

   }

   /**

    * Checks whether an entry in this table exists containing the given enzyme_id.

    *

    * @param enzymeId Enzyme ID of the entry.

    * @param con      The logical connection.

    * @return a <code>HistoryEvent</code>instance or <code>null</code> if nothing has been found.

    * @throws SQLException

    */

   public boolean futureEventExists(Long enzymeId, Connection con) throws SQLException {

     PreparedStatement findStatement = null;

     ResultSet rs = null;

     try {

       findStatement = con.prepareStatement(findStatement());

       findStatement.setLong(1, enzymeId.longValue());

       findStatement.setLong(2, enzymeId.longValue());

       rs = findStatement.executeQuery();

       if (rs.next()) {

         return true;

       }

     } finally {

             if (rs != null) rs.close();

       findStatement.close();

     }

     return false;

   }

   // ---------------- PRIVATE METHODS ----------------------

   private HistoryNode findNode(EnzymeEntry currentEntry, boolean isRoot,

                   Connection con)

   throws SQLException, DomainException {

     HistoryNode historyNode = new HistoryNode();

     historyNode.setEnzymeEntry(currentEntry);

     historyNode.setRoot(isRoot);

 // Keep history line loaded before. Ugly code but avoids another DB query.

     historyNode.setHistoryLine(currentEntry.getHistory().getRootNode().getHistoryLine());

     if (visitedNodes.containsKey(currentEntry.getId())) {

       return (HistoryNode) visitedNodes.get(currentEntry.getId()); // Stops recursion.

     }

     visitedNodes.put(currentEntry.getId(), historyNode);

     // Find event(s)

     List futureEvents = findFutureEvents(historyNode, con);

     historyNode.setEdges(futureEvents);

     return historyNode;

   }

   private List findFutureEvents(HistoryNode currentNode, Connection con)

   throws SQLException, DomainException {

     PreparedStatement findStatement = null;

     ResultSet rs = null;

     Vector result = new Vector();

     try {

       findStatement = con.prepareStatement(findStatement());

       findStatement.setLong(1, currentNode.getEnzymeEntry().getId().longValue());

       findStatement.setLong(2, currentNode.getEnzymeEntry().getId().longValue());

       rs = findStatement.executeQuery();

       while (rs.next()) {

         result.addElement(doLoad(rs, currentNode, con));

       }

     } finally {

             if (rs != null) rs.close();

             if (findStatement != null) findStatement.close();

     }

     return result;

   }

   /**

    * Creates the <code>EnzymeLink</code> object from the given result set.

    *

    * @param rs The result set object.

    * @return an <code>EnzymeLink</code> instance.

    * @throws SQLException

    */

   private FutureEvent doLoad(ResultSet rs, HistoryNode currentNode,

                   Connection con)

   throws SQLException, DomainException {

     long groupId = 0;

     long eventId = 0;

     int beforeId = 0;

     int afterId = 0;

     int enzymeId = 0;

     Date eventYear = new Date();

     Date startDate = null;

     Date dueDate = null;

     String eventNote = "";

     String eventClass = "";

     String status = "";

     int timeoutId = 0;

     if (rs.getInt(1) > 0) groupId = rs.getLong(1);

     if (rs.getInt(2) > 0) eventId = rs.getLong(2);

     if (rs.getInt(3) > 0) beforeId = rs.getInt(3);

     if (rs.getInt(4) > 0) afterId = rs.getInt(4);

     if (rs.getDate(5) != null) eventYear = rs.getDate(5);

     if (rs.getString(6) != null) eventNote = rs.getString(6);

     if (rs.getString(7) != null) eventClass = rs.getString(7);

     if (rs.getString(8) != null) status = rs.getString(8);

     if (rs.getInt(9) > 0) timeoutId = rs.getInt(9);

     if (rs.getInt(10) > 0) enzymeId = rs.getInt(10);

     if (rs.getDate(11) != null) startDate = rs.getDate(11);

     if (rs.getDate(12) != null) dueDate = rs.getDate(12);

     // Check for relative. Either beforeNode or afterNode is different from current node or one of them is null.

     EnzymeEntryMapper enzymeEntryMapper = new EnzymeEntryMapper();

     HistoryNode beforeNode = null, afterNode = null;

     if (beforeId > 0) {

       if (beforeId != currentNode.getEnzymeEntry().getId().longValue()) {

         EnzymeEntry ghostEntry = enzymeEntryMapper.findGhostById(beforeId, con);

         beforeNode = findNode(ghostEntry, false, con);

         afterNode = currentNode;

       } else {

         beforeNode = currentNode;

       }

     }

     if (afterId > 0) {

       if (afterId != currentNode.getEnzymeEntry().getId().longValue()) {

         EnzymeEntry ghostEntry = enzymeEntryMapper.findGhostById(afterId, con);

         beforeNode = currentNode;

         afterNode = findNode(ghostEntry, false, con);

       } else {

         afterNode = currentNode;

       }

     }

     Timeout timeout = new Timeout();

     timeout.setEnzymeId(enzymeId);

     timeout.setStartDate(startDate);

     timeout.setDueDate(dueDate);

     timeout.setTimeoutId(timeoutId);

     FutureEvent futureEvent = new FutureEvent();

     futureEvent.setGroupId(new Long(groupId));

     futureEvent.setEventId(new Long(eventId));

     futureEvent.setBeforeNode(beforeNode);

     futureEvent.setAfterNode(afterNode);

     futureEvent.setDate(eventYear);

     futureEvent.setNote(eventNote);

     futureEvent.setEventClass(EventConstant.valueOf(eventClass));

     futureEvent.setStatus(Status.fromCode(status));

     futureEvent.setTimeout(timeout);

     enzymeEntryMapper.close();

     return futureEvent;

   }

 }