/*******************************************************************************
 * Copyright (c) 2016 xored software, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     xored software, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.dltk.core;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.core.runtime.content.ITextContentDescriber;
import org.eclipse.dltk.utils.CharArraySequence;

public abstract class ScriptContentDescriber implements ITextContentDescriber {
	@Override
	public QualifiedName[] getSupportedOptions() {
		return new QualifiedName[] { DLTKContentTypeManager.DLTK_VALID };
	}

	private final static int BUFFER_LENGTH = 2 * 1024;
	private final static int HEADER_LENGTH = 4 * 1024;
	private final static int FOOTER_LENGTH = 4 * 1024;

	private static boolean checkHeader(File file, Pattern[] headerPatterns,
			Pattern[] footerPatterns) throws FileNotFoundException, IOException {
		FileInputStream reader = null;
		try {
			reader = new FileInputStream(file);
			byte buf[] = new byte[BUFFER_LENGTH + 1];
			int res = reader.read(buf);
			if (res == -1 || res == 0) {
				return false;
			}

			String header = new String(buf);

			if (checkBufferForPatterns(header, headerPatterns)) {
				return true;
			}
			if (file.length() < BUFFER_LENGTH && footerPatterns != null) {
				if (checkBufferForPatterns(header, footerPatterns)) {
					return true;
				}
			}

			return false;
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
				}
			}
		}
	}

	private static boolean checkFooter(File file, Pattern[] footerPatterns)
			throws FileNotFoundException, IOException {
		RandomAccessFile raFile = new RandomAccessFile(file, "r"); //$NON-NLS-1$
		try {
			long len = BUFFER_LENGTH;
			long fileSize = raFile.length();
			long offset = fileSize - len;
			if (offset < 0) {
				offset = 0;
			}
			raFile.seek(offset);
			byte buf[] = new byte[BUFFER_LENGTH + 1];
			int code = raFile.read(buf);
			if (code != -1) {
				String content = new String(buf, 0, code);
				if (checkBufferForPatterns(content, footerPatterns)) {
					return true;
				}
			}
			return false;
		} finally {
			raFile.close();
		}

	}

	private static boolean checkBufferForPatterns(CharSequence header,
			Pattern[] patterns) {
		if (patterns == null) {
			return false;
		}
		for (int i = 0; i < patterns.length; i++) {
			Matcher m = patterns[i].matcher(header);
			if (m.find()) {
				return true;
			}
		}
		return false;
	}

	public static boolean checkPatterns(File file, Pattern[] headerPatterns,
			Pattern[] footerPatterns) {
		try {
			if (checkHeader(file, headerPatterns, footerPatterns)) {
				return true;
			}
			if (footerPatterns != null && file.length() > BUFFER_LENGTH
					&& checkFooter(file, footerPatterns)) {
				return true;
			}
		} catch (FileNotFoundException e) {
			return false;
		} catch (IOException e) {
			return false;
		}
		return false;
	}

	/**
	 * Reads the specified number of bytes from the specified reader. Calls
	 * {@link Reader#read(char[], int, int)} multiple times until EOF of the
	 * specified number of bytes is read. Also catches {@link IOException} and
	 * return -1 on it.
	 * 
	 * @param reader
	 * @param bufffer
	 * @param offset
	 * @param len
	 * @return
	 */
	private static int read(Reader reader, char[] bufffer, int offset, int len) {
		try {
			int count = 0;
			while (len > 0) {
				final int result = reader.read(bufffer, offset, len);
				if (result > 0) {
					offset += result;
					len -= result;
					count += result;
				} else if (result < 0) {
					if (count == 0) {
						return result;
					} else {
						break;
					}
				}
			}
			return count;
		} catch (IOException e) {
			if (DLTKCore.DEBUG) {
				e.printStackTrace(); // ignore
			}
			return -1;
		}
	}

	public static boolean checkPatterns(Reader reader,
			Pattern[] headerPatterns, Pattern[] footerPatterns) {
		/*
		 * There is no need to use BufferedReader here since a) we read blocks,
		 * b) implementation provided by eclipse.core already do buffering.
		 */
		final int bufferSize = Math.max(HEADER_LENGTH, FOOTER_LENGTH);
		char[] buffer = new char[bufferSize];
		int len = read(reader, buffer, 0, HEADER_LENGTH);
		if (len > 0) {
			if (headerPatterns != null && headerPatterns.length > 0) {
				if (checkBufferForPatterns(new CharArraySequence(buffer, len),
						headerPatterns)) {
					return true;
				}
			}
		}
		if (footerPatterns != null && footerPatterns.length > 0) {
			char[] prevBuffer = new char[bufferSize];
			int prevLen = 0;
			for (;;) {
				final char[] tempBuffer = buffer;
				buffer = prevBuffer;
				prevBuffer = tempBuffer;
				//
				final int savedLen = prevLen;
				prevLen = len;
				len = savedLen;
				//
				len = read(reader, buffer, 0, bufferSize);
				if (len <= 0) {
					final CharSequence footer;
					if (savedLen >= FOOTER_LENGTH) {
						footer = new CharArraySequence(buffer, savedLen
								- FOOTER_LENGTH, FOOTER_LENGTH);
					} else {
						int footerLength = prevLen;
						if (savedLen > 0) {
							footerLength += savedLen;
						}
						if (footerLength > FOOTER_LENGTH) {
							footerLength = FOOTER_LENGTH;
						}
						int prevOffset = Math.max(prevLen - footerLength, 0);
						int prevSize = Math.min(prevLen, footerLength);
						if (savedLen > 0) {
							System.arraycopy(buffer, 0, buffer, footerLength
									- savedLen, savedLen);
							prevOffset += savedLen;
							prevSize -= savedLen;
						}
						if (prevSize > 0) {
							System.arraycopy(prevBuffer, prevOffset, buffer, 0,
									prevSize);
						}
						footer = new CharArraySequence(buffer, footerLength);
					}
					if (checkBufferForPatterns(footer, footerPatterns)) {
						return true;
					}
				}
				break;
			}
		}
		return false;
	}

	@Override
	public int describe(InputStream contents, IContentDescription description)
			throws IOException {
		return describe(new InputStreamReader(contents), description);
	}

	@Override
	public int describe(Reader contents, IContentDescription description)
			throws IOException {
		Pattern[] header = getHeaderPatterns();
		Pattern[] footer = getFooterPatterns();

		if (checkPatterns(contents, header, footer)) {
			if (description != null) {
				description.setProperty(DLTKContentTypeManager.DLTK_VALID,
						Boolean.TRUE);
			}
			return VALID;
		}
		return INDETERMINATE;
	}

	/**
	 * Returns an array of patterns that will be used to scan file headers to
	 * determine the script content type.
	 */
	protected abstract Pattern[] getHeaderPatterns();

	/**
	 * Returns an array of patterns that will be used to scan file footers to
	 * determine the script content type.
	 * 
	 * <p>
	 * Default implementation returns <code>null</code>. Subclasses are free to
	 * override if they wish to provide footer patterns.
	 * </p>
	 */
	protected Pattern[] getFooterPatterns() {
		return null;
	}

}