/*
 * 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.phoenix.schema;

import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;

import com.google.common.base.Preconditions;

/**
 * Specifies the sort order on disk of row key columns. The default is ASC.</p>
 * 
 * HBase always stores row keys in ascending order resulting in scans to also be
 * sorted by ascending row keys. This enum is used to associate a sort order
 * with each row key column to allow storing row key columns in descending
 * order.</p>
 * 
 * The often cited example of when you may want to do this is a row key that has
 * a date component. If all other parts of the row key are equal, a scan would
 * return the data from least recent to most recent; to get the scan to return
 * the most recent data first, the time component of the row key can be marked
 * as "desc".</p>
 * 
 * Internally, the bits of values for columns marked as "desc" are inverted before handing
 * them to HBase to persist; they are inverted again when read back out.
 * </p>
 * 
 * Example DDL:</p>
 * 
 * CREATE TABLE Events(event_type INTEGER NOT NULL, event_date DATE NOT NULL, event_name VARCHAR NOT NULL 
 * CONSTRAINT PK PRIMARY KEY (event_type, event_date DESC))</p>
 * 
 * @since 1.2
 */

public enum SortOrder {

	ASC(2) {
		@Override
		public CompareOp transform(CompareOp op) {
			return op;
		}

        @Override
        public byte normalize(byte b) {
            return b;
        }
	},

	DESC(1) {
		@Override
		public CompareOp transform(CompareOp op) {
			switch (op) {
				case EQUAL: return op;
				case NOT_EQUAL: return op;
				case NO_OP: return op;
				case GREATER: return CompareOp.LESS;
				case GREATER_OR_EQUAL: return CompareOp.LESS_OR_EQUAL;
				case LESS: return CompareOp.GREATER;
				case LESS_OR_EQUAL: return CompareOp.GREATER_OR_EQUAL;
			}
			throw new IllegalArgumentException("Add the missing case statement!");
		}

        @Override
        public byte normalize(byte b) {
            return SortOrder.invert(b);
        }
	};
	
	/**
	 * The default order that row keys are stored in.
	 */
	public static SortOrder getDefault() {
		return ASC;
	}
	
	public static byte[] invert(byte[] src, int srcOffset, byte[] dest, int dstOffset, int length) {
		Preconditions.checkNotNull(src);
		Preconditions.checkNotNull(dest);
		for (int i = 0; i < length; i++) {
			dest[dstOffset + i] = (byte) (src[srcOffset + i] ^ 0xFF);
		}
		return dest;
	}

	public static byte[] invert(byte[] src, int srcOffset, int length) {
		return invert(src, srcOffset, new byte[length], 0, length);
	}

	public static byte invert(byte b) {
		return (byte) (b ^ 0xFF);
	}
	
	/**
	 * Returns the SortOrder instance for the specified DDL stmt keyword.
	 */
	public static SortOrder fromDDLValue(String sortOrder) {
		Preconditions.checkArgument(sortOrder != null);
		if (sortOrder.equalsIgnoreCase("ASC")) {
			return ASC;
		} else if (sortOrder.equalsIgnoreCase("DESC")) {
			return DESC;
		} else {
			throw new IllegalArgumentException("Unknown SortOrder: " + sortOrder);
		}
	}

	/**
	 * Returns the SortOrder instance for the specified internal value.
	 */
	public static SortOrder fromSystemValue(int value) {
		for (SortOrder mod : SortOrder.values()) {
			if (mod.getSystemValue() == value) {
				return mod;
			}
		}
		return getDefault();
	}

	private final int serializationId;

	private SortOrder(int serializationId) {
		this.serializationId = serializationId;
	}

	/**
	 * Returns an internal value representing the specified SortOrder.
	 */
	public int getSystemValue() {
		return serializationId;
	}

	public abstract CompareOp transform(CompareOp op);
    public abstract byte normalize(byte b);
}