#' @title Cluster power curves with PAM in parallel
#'
#' @description Groups electricity power curves (or any series of similar nature) by applying PAM
#' algorithm in parallel to chunks of size \code{nb_series_per_chunk}
#'
#' @param data Access to the data, which can be of one of the three following types:
#' \itemize{
#'   \item data.frame: each line contains its ID in the first cell, and all values after
#'   \item connection: any R connection object (e.g. a file) providing lines as described above
#'   \item function: a custom way to retrieve the curves; it has two arguments: the start index
#'     (start) and number of curves (n); see example in package vignette.
#' }
#' @param K1 Number of super-consumers to be found after stage 1 (K1 << N)
#' @param K2 Number of clusters to be found after stage 2 (K2 << K1)
#' @param ntasks Number of tasks (parallel iterations to obtain K1 medoids); default: 1.
#'   Note: ntasks << N, so that N is "roughly divisible" by N (number of series)
#' @param nb_series_per_chunk (Maximum) number of series in each group, inside a task
#' @param min_series_per_chunk Minimum number of series in each group
#' @param wf Wavelet transform filter; see ?wt.filter. Default: haar
#' @param WER "end" to apply stage 2 after stage 1 has iterated and finished, or "mix"
#'   to apply it after every stage 1
#' @param ncores_tasks "MPI" number of parallel tasks (1 to disable: sequential tasks)
#' @param ncores_clust "OpenMP" number of parallel clusterings in one task
#' @param random Randomize chunks repartition
#'
#' @return A data.frame of the final medoids curves (identifiers + values)
#'
#' @examples
#' getData = function(start, n) {
#'   con = dbConnect(drv = RSQLite::SQLite(), dbname = "mydata.sqlite")
#'   df = dbGetQuery(con, paste(
#'     "SELECT * FROM times_values GROUP BY id OFFSET ",start,
#'     "LIMIT ", n, " ORDER BY date", sep=""))
#'   return (df)
#' }
#'   #TODO: 3 examples, data.frame / binary file / DB sqLite
#'   + sampleCurves : wavBootstrap de package wmtsa
#' cl = epclust(getData, K1=200, K2=15, ntasks=1000, nb_series_per_chunk=5000, WER="mix")
#' @export
epclust = function(data, K1, K2, ntasks=1, nb_series_per_chunk=50*K1, min_series_per_chunk=5*K1,
	wf="haar", WER="end", ncores_tasks=1, ncores_clust=4, random=TRUE)
{
	#0) check arguments
	if (!is.data.frame(data) && !is.function(data))
	{
		tryCatch(
			{
				if (is.character(data))
					data_con = file(data, open="r")
				else if (!isOpen(data))
				{
					open(data)
					data_con = data
				}
			},
			error=function(e) "data should be a data.frame, a function or a valid connection"
		)
	}
	K1 = toInteger(K1, function(x) x>=2)
	K2 = toInteger(K2, function(x) x>=2)
	ntasks = toInteger(ntasks)
	nb_series_per_chunk = toInteger(nb_series_per_chunk, function(x) x>=K1)
	min_series_per_chunk = toInteger(K1, function(x) x>=K1 && x<=nb_series_per_chunk)
	ncores_tasks = toInteger(ncores_tasks, function(x) x>=1)
	ncores_clust = toInteger(ncores_clust, function(x) x>=1)
	if (WER!="end" && WER!="mix")
		stop("WER takes values in {'end','mix'}")

	#1) Serialize all wavelets coefficients (+ IDs) onto a file
	coeffs_file = ".coeffs"
	index = 1
	nb_curves = 0
	nb_coeffs = NA
	repeat
	{
		coeffs_chunk = computeCoeffs(data, index, nb_series_per_chunk, wf)
		if (is.null(coeffs_chunk))
			break
		serialized_coeffs = serialize(coeffs_chunk)
		appendBinary(coeffs_file, serialized_coeffs)
		index = index + nb_series_per_chunk
		nb_curves = nb_curves + nrow(coeffs_chunk)
		if (is.na(nb_coeffs))
			nb_coeffs = ncol(coeffs_chunk)-1
	}

#	finalizeSerialization(coeffs_file) ........, nb_curves, )
#TODO: is it really useful ?! we will always have these informations (nb_curves, nb_coeffs)

	if (nb_curves < min_series_per_chunk)
		stop("Not enough data: less rows than min_series_per_chunk!")
	nb_series_per_task = round(nb_curves / ntasks)
	if (nb_series_per_task < min_series_per_chunk)
		stop("Too many tasks: less series in one task than min_series_per_chunk!")

	#2) Cluster coefficients in parallel (by nb_series_per_chunk)
	# All indices, relative to complete dataset
	indices = if (random) sample(nb_curves) else seq_len(nb_curves)
	# Indices to be processed in each task
	indices_tasks = list()
	for (i in seq_len(ntasks))
	{
		upper_bound = ifelse( i<ntasks, min(nb_series_per_task*i,nb_curves), nb_curves )
		indices_task[[i]] = indices[((i-1)*nb_series_per_task+1):upper_bound]
	}
	library(parallel, quietly=TRUE)
	cl_tasks = parallel::makeCluster(ncores_tasks)
	parallel::clusterExport(cl_tasks, ..........ncores_clust, indices_tasks, nb_series_per_chunk, processChunk, K1,
									 K2, WER, )
	ranks = parallel::parSapply(cl_tasks, seq_along(indices_tasks), oneIteration)
	parallel::stopCluster(cl_tasks)

	#3) Run step1+2 step on resulting ranks
	ranks = oneIteration(.........)
	return (list("ranks"=ranks, "medoids"=getSeries(data, ranks)))
}