/*****************************************************************
 *   Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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.apache.cayenne.dba.sqlserver;

import org.apache.cayenne.ObjectId;
import org.apache.cayenne.ResultIterator;
import org.apache.cayenne.access.DataNode;
import org.apache.cayenne.access.OperationObserver;
import org.apache.cayenne.access.jdbc.ProcedureAction;
import org.apache.cayenne.access.jdbc.RowDescriptor;
import org.apache.cayenne.access.translator.procedure.ProcedureTranslator;
import org.apache.cayenne.query.ProcedureQuery;
import org.apache.cayenne.query.Query;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * ProcedureAction for SQLServer MS JDBC driver. Customizes OUT parameter
 * processing - it has to be done AFTER the ResultSets are read (note that jTDS
 * driver works fine with normal ProcedureAction).
 * <p>
 * <i>See JIRA CAY-251 for details. </i>
 * </p>
 * 
 * @since 1.2
 */
public class SQLServerProcedureAction extends ProcedureAction {

	/**
	 * @since 4.0
	 */
	public SQLServerProcedureAction(ProcedureQuery query, DataNode dataNode) {
		super(query, dataNode);
	}

	@Override
	public void performAction(Connection connection, OperationObserver observer) throws SQLException, Exception {

		ProcedureTranslator transl = createTranslator(connection);

		try (CallableStatement statement = (CallableStatement) transl.createStatement();) {
			// stored procedure may contain a mixture of update counts and
			// result sets,
			// and out parameters. Read out parameters first, then
			// iterate until we exhaust all results
			boolean hasResultSet = statement.execute();

			// local observer to cache results and provide them to the external
			// observer
			// in the order consistent with other adapters.

			Observer localObserver = new Observer(observer);

			// read query, using local observer

			while (true) {
				if (hasResultSet) {

					try (ResultSet rs = statement.getResultSet();) {
						RowDescriptor descriptor = describeResultSet(rs, processedResultSets++);
						readResultSet(rs, descriptor, query, localObserver);
					}
				} else {
					int updateCount = statement.getUpdateCount();
					if (updateCount == -1) {
						break;
					}
					dataNode.getJdbcEventLogger().logUpdateCount(updateCount);
					localObserver.nextCount(query, updateCount);
				}

				hasResultSet = statement.getMoreResults();
			}

			// read out parameters to the main observer ... AFTER the main
			// result set
			// TODO: I hope SQLServer does not support ResultSets as OUT
			// parameters,
			// otherwise
			// the order of custom result descriptors will be messed up
			readProcedureOutParameters(statement, observer);

			// add results back to main observer
			localObserver.flushResults(query);
		}
	}

	class Observer implements OperationObserver {

		List<List<?>> results;
		List<Integer> counts;
		OperationObserver observer;

		Observer(OperationObserver observer) {
			this.observer = observer;
		}

		void flushResults(Query query) {
			if (results != null) {
				for (List<?> result : results) {
					observer.nextRows(query, result);
				}
				results = null;
			}

			if (counts != null) {
				for (Integer count : counts) {
					observer.nextCount(query, count);
				}
				counts = null;
			}
		}

		@Override
		public void nextBatchCount(Query query, int[] resultCount) {
			observer.nextBatchCount(query, resultCount);
		}

		@Override
		public void nextCount(Query query, int resultCount) {
			// does not delegate to wrapped observer
			// but instead caches results locally.
			if (counts == null) {
				counts = new ArrayList<>();
			}

			counts.add(Integer.valueOf(resultCount));
		}

		@Override
		public void nextRows(Query query, List<?> dataRows) {
			// does not delegate to wrapped observer
			// but instead caches results locally.
			if (results == null) {
				results = new ArrayList<>();
			}

			results.add(dataRows);
		}

		@Override
		public void nextRows(Query q, ResultIterator it) {
			observer.nextRows(q, it);
		}

		@Override
		public void nextGlobalException(Exception ex) {
			observer.nextGlobalException(ex);
		}

		@Override
		public void nextGeneratedRows(Query query, ResultIterator keys, ObjectId idToUpdate) {
			observer.nextGeneratedRows(query, keys, idToUpdate);
		}

		@Override
		public void nextQueryException(Query query, Exception ex) {
			observer.nextQueryException(query, ex);
		}

		@Override
		public boolean isIteratedResult() {
			return observer.isIteratedResult();
		}
	}
}