/*
 * Copyright @ 2013 CurisTEC, S.A.S. All Rights Reserved.
 */
package net.curisit.securis.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.TimeoutException;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import net.curisit.integrity.exception.CurisRuntimeException;

/**
 * Utils
 * <p>
 * General-purpose static utilities: hashing, dates/times, collections, I/O helpers,
 * simple email validation, reflection helpers, file tailing, etc.
 *
 * Author: JRA
 * Last reviewed by JRA on Oct 6, 2025.
 */
public class Utils {

	private static final Logger LOG = LogManager.getLogger(Utils.class);

	/* --------------------- Hash functions --------------------- */

	/**
	 * md5<p>
	 * Returns MD5 digest (hex, 32 chars) for the input text.
	 *
	 * @param str source text
	 * @return lowercase hex MD5 or null on error
	 */
	public static String md5(String str) {
		try {
			MessageDigest mDigest = MessageDigest.getInstance("MD5");
			mDigest.update(str.getBytes(), 0, str.length());
			BigInteger i = new BigInteger(1, mDigest.digest());
			return String.format("%1$032x", i);
		} catch (NoSuchAlgorithmException e) {
			LOG.error("Error generating MD5 for string: " + str, e);
		}
		return null;
	}

	/**
	 * sha1<p>
	 * Returns SHA-1 digest (hex, 40 chars) for the input text.
	 *
	 * @param str source text
	 * @return lowercase hex SHA-1 or null on error
	 */
	public static String sha1(String str) {
		try {
			MessageDigest mDigest = MessageDigest.getInstance("SHA1");
			mDigest.update(str.getBytes(), 0, str.length());
			BigInteger i = new BigInteger(1, mDigest.digest());
			return String.format("%1$040x", i);
		} catch (NoSuchAlgorithmException e) {
			LOG.error("Error generating SHA1 for string: " + str, e);
		}
		return null;
	}

	/**
	 * sha256<p>
	 * Returns SHA-256 digest (hex, 64 chars) for the input text.
	 *
	 * @param str source text
	 * @return lowercase hex SHA-256 or null on error
	 */
	public static String sha256(String str) {
		return sha256(str.getBytes());
	}

	/**
	 * sha256<p>
	 * Returns SHA-256 digest (hex) for a byte array.
	 *
	 * @param bytes data
	 * @return hex SHA-256 or null on error
	 */
	public static String sha256(byte[] bytes) {
		try {
			MessageDigest mDigest = MessageDigest.getInstance("SHA-256");
			mDigest.update(bytes, 0, bytes.length);
			BigInteger i = new BigInteger(1, mDigest.digest());
			return String.format("%1$064x", i);
		} catch (NoSuchAlgorithmException e) {
			LOG.error("Error generating SHA-256 for bytes: " + bytes, e);
		}
		return null;
	}

	/**
	 * sha256<p>
	 * Incrementally updates SHA-256 with multiple byte arrays and returns hex digest.
	 *
	 * @param bytes multiple byte chunks
	 * @return hex SHA-256 or null on error
	 */
	public static String sha256(byte[]... bytes) {
		try {
			MessageDigest mDigest = MessageDigest.getInstance("SHA-256");
			for (byte[] bs : bytes) {
				mDigest.update(bs, 0, bs.length);
			}
			BigInteger i = new BigInteger(1, mDigest.digest());
			return String.format("%1$064x", i);
		} catch (NoSuchAlgorithmException e) {
			LOG.error("Error generating SHA-256 for bytes: " + bytes, e);
		}
		return null;
	}
	
	/* --------------------- ISO date helpers --------------------- */

	private static final String ISO_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
	private static final SimpleDateFormat sdf = new SimpleDateFormat(ISO_PATTERN);
	static {
		sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
	}

	/**
	 * toIsoFormat<p>
	 * Formats a Date to ISO-8601-like string with milliseconds in GMT.
	 *
	 * @param date input date
	 * @return formatted string
	 */
	public static synchronized String toIsoFormat(Date date) {
		return sdf.format(date);
	}	

	private static final String ISO_PATTERN_REDUCED_PRECISION = "yyyy-MM-dd'T'HH:mm:ssZ";
	private static final SimpleDateFormat sdfReduced = new SimpleDateFormat(ISO_PATTERN_REDUCED_PRECISION);
	static {
		sdfReduced.setTimeZone(TimeZone.getTimeZone("GMT"));
	}

	/**
	 * toIsoFormatReduced<p>
	 * Formats a Date to ISO string without milliseconds in GMT.
	 *
	 * @param date input date
	 * @return formatted string
	 */
	public static synchronized String toIsoFormatReduced(Date date) {
		return sdfReduced.format(date);
	}

	/**
	 * toDateFromIso<p>
	 * Parses a string in {@link #ISO_PATTERN} into a Date (GMT).
	 *
	 * @param dateStr string to parse
	 * @return Date or null if parsing fails
	 */
	public static synchronized Date toDateFromIso(String dateStr) {
		try {
			return sdf.parse(dateStr);
		} catch (ParseException e) {
			LOG.error("Error parsing string '{}' to Date object with pattern: {}", dateStr, ISO_PATTERN);
			return null;
		}
	}

	/* --------------------- Null-safe helpers --------------------- */

	/**
	 * nonull<p>
	 * Returns {@code value} cast to T, or {@code defaultValue} if null.
	 *
	 * @param value input
	 * @param defaultValue fallback
	 * @return value or default
	 */
	@SuppressWarnings("unchecked")
	public static <T> T nonull(Object value, T defaultValue) {
		return value == null ? defaultValue : (T) value;
	}

	/**
	 * nonull<p>
	 * Returns String value or empty string if null.
	 *
	 * @param value input
	 * @return non-null string
	 */
	public static String nonull(Object value) {
		return nonull(value, "");
	}

	/**
	 * value<p>
	 * Unchecked cast helper (avoid using unless necessary).
	 *
	 * @param value object
	 * @param type  target type
	 * @return casted value
	 */
	@SuppressWarnings("unchecked")
	public static <T> T value(Object value, Class<T> type) {
		return (T) value;
	}

	/**
	 * createMap<p>
	 * Convenience to create a Map from varargs key/value pairs.
	 *
	 * @param keyValue alternating key, value
	 * @return map with pairs
	 */
	@SuppressWarnings("unchecked")
	public static <K extends Object, V extends Object> Map<K, V> createMap(Object... keyValue) {
		Map<K, V> map = (Map<K, V>) new HashMap<Object, Object>();
		for (int i = 0; i < keyValue.length; i += 2) {
			((Map<Object, Object>) map).put(keyValue[i], keyValue[i + 1]);
		}
		return map;
	}

	/* --------------------- Date arithmetic --------------------- */

	/**
	 * addDays<p>
	 * Adds a number of days to a Date.
	 *
	 * @param date base date
	 * @param days positive/negative days
	 * @return new Date
	 */
	public static Date addDays(Date date, int days) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.DATE, days);
		return cal.getTime();
	}

	/**
	 * addHours<p>
	 * Adds hours to a Date.
	 *
	 * @param date base date
	 * @param hours number of hours
	 * @return new Date
	 */
	public static Date addHours(Date date, int hours) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.HOUR, hours);
		return cal.getTime();
	}

	/**
	 * addMinutes<p>
	 * Adds minutes to a Date.
	 *
	 * @param date base date
	 * @param minutes number of minutes
	 * @return new Date
	 */
	public static Date addMinutes(Date date, int minutes) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.MINUTE, minutes);
		return cal.getTime();
	}

	/**
	 * getStrTime<p>
	 * Formats seconds as H:MM:SS (H omitted if 0). Negative yields "??".
	 *
	 * @param seconds total seconds
	 * @return formatted time
	 */
	public static String getStrTime(int seconds) {
		if (seconds < 0)
			return "??";
		String secs = String.format("%02d", seconds % 60);
		String hours = "";
		String mins = "0:";
		if (seconds > 3600) {
			hours = String.format("%d:", seconds / 3600);
		}
		if (seconds > 60) {
			mins = String.format("%02d:", (seconds / 60) % 60);
		}
		return hours + mins + secs;
	}

	/* --------------------- Collections & conversions --------------------- */

	/**
	 * areAllEmpty<p>
	 * Checks if all provided collections are empty.
	 *
	 * @param lists vararg of collections
	 * @return true if all empty
	 */
	public static boolean areAllEmpty(Collection<?>... lists) {
		for (Collection<?> list : lists) {
			if (!list.isEmpty())
				return false;
		}
		return true;
	}

	/**
	 * toDateFromLocalDate<p>
	 * Converts a {@link LocalDate} to {@link Date} at system default zone start of day.
	 *
	 * @param ld local date
	 * @return Date or null
	 */
	public static Date toDateFromLocalDate(LocalDate ld) {
		if (ld == null)
			return null;
		Instant instant = ld.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant();
		return Date.from(instant);
	}

	/**
	 * toLocalDateFromDate<p>
	 * Converts a {@link Date} to {@link LocalDate} at system default zone.
	 *
	 * @param date Date
	 * @return LocalDate or null
	 */
	public static LocalDate toLocalDateFromDate(Date date) {
		if (date == null)
			return null;
		Instant instant = Instant.ofEpochMilli(date.getTime());
		return LocalDateTime.ofInstant(instant, ZoneId.systemDefault()).toLocalDate();
	}

	/**
	 * compare<p>
	 * Null-safe equals: both null → true; otherwise {@code equals()}.
	 *
	 * @param obj1 first object
	 * @param obj2 second object
	 * @return equality result
	 */
	public static boolean compare(Object obj1, Object obj2) {
		if (obj1 == null) {
			return obj2 == null;
		} else {
			return obj1.equals(obj2);
		}
	}

	/* --------------------- Email validation --------------------- */

	private static final String EMAIL_PATTERN_STR = "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@" + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
	private static final Pattern EMAIL_PATTERN = Pattern.compile(EMAIL_PATTERN_STR);

	/**
	 * isValidEmail<p>
	 * Validates an email address format with a basic regex.
	 *
	 * @param email candidate value
	 * @return valid or not
	 */
	public static boolean isValidEmail(final String email) {
		if (email == null) {
			return false;
		}
		return EMAIL_PATTERN.matcher(email).matches();
	}

	/* --------------------- Iterable helpers --------------------- */

	/**
	 * Reversed<p>
	 * Iterable wrapper to iterate a List in reverse order without copying.
	 *
	 * @param <T> element type
	 */
	public static class Reversed<T> implements Iterable<T> {
		private final List<T> original;

		public Reversed(List<T> original) {
			this.original = original;
		}

		public Iterator<T> iterator() {
			return new Iterator<T>() {
				int cursor = original.size();
				public boolean hasNext() { return cursor > 0; }
				public T next() { return original.get(--cursor); }
				public void remove() { throw new CurisRuntimeException("ERROR removing item in read-only iterator"); }
			};
		}
	}

	/**
	 * reversedList<p>
	 * Returns a reversed-iteration view of a list.
	 *
	 * @param original list to view
	 * @param <T> element type
	 * @return iterable reverse view
	 */
	public static <T> Reversed<T> reversedList(List<T> original) {
		return new Reversed<T>(original);
	}

	/**
	 * isSorted<p>
	 * Checks if a list of Doubles is non-decreasing.
	 *
	 * @param original list
	 * @return true if sorted ascending
	 */
	public static boolean isSorted(List<Double> original) {
		for (int i = 0; i < (original.size() - 1); i++) {
			Double v0 = original.get(i);
			Double v1 = original.get(i + 1);
			if (v0.doubleValue() > v1.doubleValue()) {
				return false;
			}
		}
		return true;
	}

	/* --------------------- Simple file reading helpers --------------------- */

	/**
	 * readFileLines<p>
	 * Reads a file as UTF-8 and splits each line by a separator.
	 *
	 * @param file source file
	 * @param separator regex separator
	 * @return list of line fields
	 * @throws IOException on I/O errors
	 */
	public static List<List<String>> readFileLines(File file, final String separator) throws IOException {
		List<String> lines = Files.readAllLines(Paths.get(file.toURI()), Charset.forName("utf8"));
		return lines.stream().map(line -> Arrays.asList(line.split(separator))).collect(Collectors.toList());
	}

	/**
	 * readStreamLines<p>
	 * Reads an InputStream as UTF-8 and splits each line by a separator.
	 *
	 * @param stream input stream (caller closes it)
	 * @param separator regex separator
	 * @return list of line fields
	 * @throws IOException on I/O errors
	 */
	public static List<List<String>> readStreamLines(InputStream stream, final String separator) throws IOException {
		try (
				InputStreamReader isr = new InputStreamReader(stream, Charset.forName("UTF-8"));
				BufferedReader br = new BufferedReader(isr);
				) {
			String line;
			List<List<String>> lines = new ArrayList<>(); 
			while ((line = br.readLine()) != null) {
				lines.add(Arrays.asList(line.split(separator))); 
			}
			return lines;
		}
	}

	/**
	 * deleteDirectoryTree<p>
	 * Recursively deletes a directory and its contents.
	 *
	 * @param baseDirectory directory path
	 * @throws IOException on failure
	 */
	public static void deleteDirectoryTree(Path baseDirectory) throws IOException {
		Files.walkFileTree(baseDirectory, new SimpleFileVisitor<Path>() {
			@Override
			public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
				Files.deleteIfExists(file);
				return FileVisitResult.CONTINUE;
			}
			@Override
			public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
				Files.deleteIfExists(dir);
				return FileVisitResult.CONTINUE;
			}
		});
	}

	/* --------------------- Directory size & tail --------------------- */

	private static class LongWrapper { long num = 0L; }

	/**
	 * getDirectoryContentSize<p>
	 * Computes total size (bytes) of files within a directory tree.
	 *
	 * @param baseDirectory root path
	 * @return total bytes
	 * @throws IOException on traversal errors
	 */
	public static long getDirectoryContentSize(Path baseDirectory) throws IOException {
		final LongWrapper size = new LongWrapper();
		Files.walkFileTree(baseDirectory, new SimpleFileVisitor<Path>() {
			@Override
			public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
				size.num += file.toFile().length();
				return FileVisitResult.CONTINUE;
			}
			@Override
			public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
				if (!dir.equals(baseDirectory)) {
					size.num += dir.toFile().length();
				}
				return FileVisitResult.CONTINUE;
			}
		});
		return size.num;
	}

	/**
	 * waitFor<p>
	 * Asynchronously waits until a condition is true or a timeout is reached.
	 *
	 * @param condition supplier that should eventually return true
	 * @param timeout max wait (ms)
	 * @return future completing with true if condition met
	 * @throws TimeoutException surfaced through CompletionException if timed out
	 */
	public static CompletableFuture<Boolean> waitFor(Supplier<Boolean> condition, long timeout) throws TimeoutException {
		return CompletableFuture.<Boolean>supplyAsync(() -> {
			long t0 = System.currentTimeMillis();
			while(!condition.get()) {
				long t1 = System.currentTimeMillis();
				if ((t1 - t0) > timeout) {
					throw new CompletionException(new TimeoutException()); 
				}
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					throw new CompletionException(e); 
				}
			}
			return true;
		});
	}

	private static final int BLOCK_SIZE = 4096; // 4KB

	/**
	 * getLastLines<p>
	 * Efficiently reads the last N lines of a text file by scanning from the end in blocks.
	 *
	 * @param file file to read
	 * @param numLines number of lines from the end
	 * @return list of lines in natural order (oldest→newest among the last N)
	 * @throws IOException on I/O errors
	 */
	public static List<String> getLastLines(File file, int numLines) throws IOException {
		LinkedList<String> lines = new LinkedList<>();
		long fileSize = file.length();
		int chunk = (fileSize < BLOCK_SIZE) ? (int)fileSize : BLOCK_SIZE;
		long seekPos = fileSize - chunk;
		FileChannel fc = FileChannel.open(file.toPath(), StandardOpenOption.READ);
		final byte newLine = (byte)'\n';
		String partialLine = null;
		while (lines.size() < numLines) {
			ByteBuffer dst = ByteBuffer.allocate(chunk);
			int bytesRead = fc.read(dst, seekPos);
			byte[] content = dst.array();
			int lastLineIdx = bytesRead;  
			for (int i = bytesRead - 1; i > 0 ; i--) {
				byte b = content[i];
				if (b == newLine) {
					if (i < (bytesRead - 1) || partialLine != null) {
						String line = new String(Arrays.copyOfRange(content, i, lastLineIdx)).trim();
						if (partialLine != null) {
							line += partialLine;
							partialLine = null;
						}
						lines.addFirst(line);
						if (lines.size() == numLines) {
							return lines;
						}
					}
					lastLineIdx = i;
				}
			}
			if (lastLineIdx > 0) {
				if (partialLine == null) {
					partialLine = new String(Arrays.copyOfRange(content, 0, lastLineIdx)).trim();
				} else {
					partialLine = new String(Arrays.copyOfRange(content, 0, lastLineIdx)) + partialLine;
				}
			}
			if (seekPos == 0) {
				lines.addFirst(partialLine);
				break;
			}
			if (seekPos < BLOCK_SIZE) {
				chunk = (int)seekPos;
				seekPos = 0;				
			} else {
				seekPos -= BLOCK_SIZE;
			}
		}
		return lines;
	}

	/**
	 * removeDuplicates<p>
	 * Returns a sorted list without duplicates using a set roundtrip.
	 *
	 * @param list input list
	 * @param <T> type must be Comparable
	 * @return sorted distinct list
	 */
	public static <T> List<T> removeDuplicates(List<T> list) {
		return new HashSet<>(list).stream().sorted().collect(Collectors.toList());		
	}

	/* --------------------- Reflection helpers --------------------- */

	/**
	 * setProperty<p>
	 * Sets a bean property by name using Apache BeanUtils PropertyUtils.
	 *
	 * @param bean target bean
	 * @param fieldName property name (nested supported)
	 * @param value value to assign
	 * @throws RuntimeException wrapping reflection errors
	 */
	public static void setProperty(Object bean, String fieldName, Object value) {
		try {
			PropertyUtils.setProperty(bean, fieldName, value);
		} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
			LOG.error("Missing field:" + fieldName);
			throw new RuntimeException(e);
		}
	}

	/**
	 * getProperty<p>
	 * Reads a bean property by name using Apache PropertyUtils.
	 *
	 * @param bean target bean
	 * @param fieldName property name
	 * @return value
	 * @throws RuntimeException wrapping reflection errors
	 */
	public static Object getProperty(Object bean, String fieldName) {
		try {
			return PropertyUtils.getProperty(bean, fieldName);
		} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
			LOG.error("Missing field:" + fieldName);
			throw new RuntimeException(e);
		}
	}

	/**
	 * cloneBean<p>
	 * Clones a bean using Apache BeanUtils' copy mechanisms (shallow copy).
	 *
	 * @param bean source bean
	 * @return new cloned bean
	 * @throws CurisRuntimeException on cloning errors
	 */
	public static Object cloneBean(Object bean) {
		try {
			return BeanUtils.cloneBean(bean);
		} catch (IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) {
			throw new CurisRuntimeException("Error cloning bean", e);
		}	
	}
}