/*
 * 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.sysds.runtime.compress.colgroup.indexes;

import java.io.DataOutput;
import java.io.IOException;

/**
 * Class to contain column indexes for the compression column groups.
 */
public interface IColIndex {

	public static enum ColIndexType {
		SINGLE, TWO, ARRAY, RANGE, UNKNOWN;
	}

	/**
	 * Get the size of the index aka, how many columns is contained
	 * 
	 * @return The size of the array
	 */
	public int size();

	/**
	 * Get the index at a specific location, Note that many of the underlying implementations does not throw exceptions
	 * on indexes that are completely wrong, so all implementations that use this index should always be well behaved.
	 * 
	 * @param i The index to get
	 * @return the column index at the index.
	 */
	public int get(int i);

	/**
	 * Return a new column index where the values are shifted by the specified amount.
	 * 
	 * It is returning a new instance of the index.
	 * 
	 * @param i The amount to shift
	 * @return the new instance of an index.
	 */
	public IColIndex shift(int i);

	/**
	 * Write out the IO representation of this column index
	 * 
	 * @param out The Output to write into
	 * @throws IOException IO exceptions in case of for instance not enough disk space
	 */
	public void write(DataOutput out) throws IOException;

	/**
	 * Get the exact size on disk to enable preallocation of the disk output buffer sizes
	 * 
	 * @return The exact disk representation size
	 */
	public long getExactSizeOnDisk();

	/**
	 * Get the in memory size of this object.
	 * 
	 * @return The memory size of this object
	 */
	public long estimateInMemorySize();

	/**
	 * A Iterator of the indexes see the iterator interface for details.
	 * 
	 * @return A iterator for the indexes contained.
	 */
	public IIterate iterator();

	/**
	 * Find the index of the value given return negative if non existing.
	 * 
	 * @param i the value to find inside the allocation
	 * @return The index of the value.
	 */
	public int findIndex(int i);

	public SliceResult slice(int l, int u);

	@Override
	public boolean equals(Object other);

	public boolean equals(IColIndex other);

	@Override
	public int hashCode();

	/**
	 * This contains method is not strict since it only verifies one element is contained from each a and b.
	 * 
	 * @param a one array to contain at least one value from
	 * @param b another array to contain at least one value from
	 * @return if the other arrays contain values from this array
	 */
	public boolean contains(IColIndex a, IColIndex b);

	/**
	 * This contains both a and b ... it is strict because it verifies all cells.
	 * 
	 * Note it returns false if there are more elements in this than the sum of a and b.
	 * 
	 * @param a one other array to contain
	 * @param b another array to contain
	 * @return if this array contains both a and b
	 */
	public boolean containsStrict(IColIndex a, IColIndex b);

	/**
	 * combine the indexes of this colIndex with another, it is expected that all calls to this contains unique indexes,
	 * and no copies of values.
	 * 
	 * @param other The other array
	 * @return The combined array
	 */
	public IColIndex combine(IColIndex other);

	/**
	 * Get if these columns are contiguous, meaning all indexes are integers at increments of 1.
	 * 
	 * ex:
	 * 
	 * 1,2,3,4,5,6 is contiguous
	 * 
	 * 1,3,4 is not.
	 * 
	 * @return If the Columns are contiguous.
	 */
	public boolean isContiguous();

	/**
	 * If the columns are not in sorted incrementing order this method can be called to get the sorting index for this
	 * set of column indexes.
	 * 
	 * The returned list should be the mapping of elements for each column to where it should be after sorting.
	 * 
	 * @return A Reordered index.
	 */
	public int[] getReorderingIndex();

	/**
	 * Get if the Index is sorted.
	 * 
	 * @return If the index is sorted
	 */
	public boolean isSorted();

	/**
	 * Sort the index and return a new object if there are modifications otherwise return this.
	 * 
	 * @return The sorted instance of this column index.
	 */
	public IColIndex sort();

	/**
	 * Analyze if this column group contain the given column id
	 * 
	 * @param i id to search for
	 * @return if it is contained
	 */
	public boolean contains(int i);

	/**
	 * Analyze if this column group contain any of the given column Ids.
	 * 
	 * @param idx A List of indexes
	 * @return If it is contained
	 */
	public boolean containsAny(IColIndex idx);

	/** A Class for slice results containing indexes for the slicing of dictionaries, and the resulting column index */
	public static class SliceResult {
		/** Start index to slice inside the dictionary */
		public final int idStart;
		/** End index (not inclusive) to slice inside the dictionary */
		public final int idEnd;
		/** The already modified column index to return on slices */
		public final IColIndex ret;

		protected SliceResult(int idStart, int idEnd, IColIndex ret) {
			this.idStart = idStart;
			this.idEnd = idEnd;
			this.ret = ret;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder(50);
			sb.append("SliceResult:[");
			sb.append(idStart);
			sb.append("-");
			sb.append(idEnd);
			sb.append(" ");
			sb.append(ret);
			sb.append("]");
			return sb.toString();
		}
	}
}