package org.argeo.util;

import java.io.PrintStream;
import java.nio.charset.Charset;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/** Hashes the hashes of the files in a directory.*/
public class DirH {

	private final static Charset charset = Charset.forName("UTF-16");
	private final static long bufferSize = 200 * 1024 * 1024;
	private final static String algorithm = "SHA";

	private final static byte EOL = (byte) '\n';
	private final static byte SPACE = (byte) ' ';

	private final int hashSize;

	private final byte[][] hashes;
	private final byte[][] fileNames;
	private final byte[] digest;
	private final byte[] dirName;

	/**
	 * @param dirName
	 *            can be null or empty
	 */
	private DirH(byte[][] hashes, byte[][] fileNames, byte[] dirName) {
		if (hashes.length != fileNames.length)
			throw new UtilsException(hashes.length + " hashes and " + fileNames.length + " file names");
		this.hashes = hashes;
		this.fileNames = fileNames;
		this.dirName = dirName == null ? new byte[0] : dirName;
		if (hashes.length == 0) {// empty dir
			hashSize = 20;
			// FIXME what is the digest of an empty dir?
			digest = new byte[hashSize];
			Arrays.fill(digest, SPACE);
			return;
		}
		hashSize = hashes[0].length;
		for (int i = 0; i < hashes.length; i++) {
			if (hashes[i].length != hashSize)
				throw new UtilsException(
						"Hash size for " + new String(fileNames[i], charset) + " is " + hashes[i].length);
		}

		try {
			MessageDigest md = MessageDigest.getInstance(algorithm);
			for (int i = 0; i < hashes.length; i++) {
				md.update(this.hashes[i]);
				md.update(SPACE);
				md.update(this.fileNames[i]);
				md.update(EOL);
			}
			digest = md.digest();
		} catch (NoSuchAlgorithmException e) {
			throw new UtilsException("Cannot digest", e);
		}
	}

	public void print(PrintStream out) {
		out.print(DigestUtils.encodeHexString(digest));
		if (dirName.length > 0) {
			out.print(' ');
			out.print(new String(dirName, charset));
		}
		out.print('\n');
		for (int i = 0; i < hashes.length; i++) {
			out.print(DigestUtils.encodeHexString(hashes[i]));
			out.print(' ');
			out.print(new String(fileNames[i], charset));
			out.print('\n');
		}
	}

	public static DirH digest(Path dir) {
		try (DirectoryStream<Path> files = Files.newDirectoryStream(dir)) {
			List<byte[]> hs = new ArrayList<byte[]>();
			List<String> fNames = new ArrayList<>();
			for (Path file : files) {
				if (!Files.isDirectory(file)) {
					byte[] digest = DigestUtils.digestRaw(algorithm, file, bufferSize);
					hs.add(digest);
					fNames.add(file.getFileName().toString());
				}
			}

			byte[][] fileNames = new byte[fNames.size()][];
			for (int i = 0; i < fNames.size(); i++) {
				fileNames[i] = fNames.get(i).getBytes(charset);
			}
			byte[][] hashes = hs.toArray(new byte[hs.size()][]);
			return new DirH(hashes, fileNames, dir.toString().getBytes(charset));
		} catch (Exception e) {
			throw new UtilsException("Cannot digest " + dir, e);
		}
	}

	public static void main(String[] args) {
		try {
			DirH dirH = DirH.digest(Paths.get("/home/mbaudier/tmp/"));
			dirH.print(System.out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}