package fr.uge.code.camp;

import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Optional;
import java.util.Set;


public class Session1 {

	/**
	 * Renvoie le nombre d'occurrences d'un élément donné dans une liste.
	 *
	 * @param <E>     le type des éléments de la liste
	 * @param list    la liste à parcourir
	 * @param element l'élément dont on veut compter les occurrences
	 * @return le nombre de fois que l'élément apparaît dans la liste
	 */
	public static <E> long numberOfOccurrences(List<E> list, E element) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Vérifie si tous les éléments de la liste sont distincts (uniques).
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à vérifier
	 * @return true si la liste ne contient aucun doublon, false sinon
	 */
	public static <E> boolean allDistinct(List<E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Convertit une liste en une chaîne de caractères où les éléments sont séparés
	 * par un point-virgule.
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à convertir
	 * @return une chaîne de caractères représentant la liste
	 */
	public static <E> String listToString(List<E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Renvoie un des éléments les plus fréquents de la liste.
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à analyser
	 * @return un Optional contenant l'élément le plus fréquent, ou un Optional vide
	 *         si la liste est vide
	 */
	public static <E> Optional<E> mostFrequent(List<? extends E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Renvoie une nouvelle liste contenant les mêmes éléments que la liste
	 * d'origine, mais sans doublons, en conservant l'ordre de première apparition.
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à filtrer
	 * @return une liste sans doublons
	 */
	public static <E> List<E> withoutDuplicates(List<? extends E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Renvoie une liste des éléments qui apparaissent plus d'une fois, mais chaque
	 * élément n'apparaît qu'une seule fois dans le résultat. L'ordre correspond à
	 * la première fois qu'un élément est détecté comme doublon.
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à analyser
	 * @return une liste des valeurs dupliquées (sans répétition dans le résultat)
	 */
	public static <E> List<E> oneOfEachDuplicate(List<? extends E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Renvoie un ensemble des éléments qui n'apparaissent qu'à des positions paires
	 * dans la liste.
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à analyser
	 * @return un ensemble des éléments qui n'apparaissent qu'aux positions paires
	 */
	public static <E> Set<E> onlyEvenPosition(List<? extends E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Renvoie un ensemble des éléments qui n'apparaissent qu'une seule fois (les
	 * éléments uniques).
	 *
	 * @param <E>  le type des éléments de la liste
	 * @param list la liste à analyser
	 * @return un ensemble des éléments uniques
	 */
	public static <E> Set<E> singles(List<? extends E> list) {
		throw new UnsupportedOperationException("Not implemented yet");
	}

	
	
	/**
	 * Prend en entrée un fichier contenant un ou plusieurs entiers par ligne
	 * Vérifie qu'il ne comporte aucun doublon. 
	 *
	 * @param path le chemin vers le fichier à vérifier
	 * @return true si tous les entiers sont uniques, false sinon
	 * @throws IOException           si une erreur de lecture survient
	 * @throws NumberFormatException si une ligne ne contient pas un entier valide
	 */
	public static boolean allDistinctInFile(Path path) throws IOException {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Commpte le nombre d'entiers distincts dans un fichier contenant un ou
	 * plusieurs entiers par ligne, séparés par des espaces.
	 *
	 * @param path le chemin vers le fichier à vérifier
	 * @return return le nombre d'entiers distincts
	 * @throws IOException           si une erreur de lecture survient
	 * @throws NumberFormatException si une ligne ne contient pas un entier valide
	 */
	public static int numberOfDistinctsNumbersInFile(Path path) throws IOException {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Prend en entrée un fichier contenant deux entiers par ligne, un id et une
	 * valeur, séparés par un espace. Renvoie la moyenne (arrondie à l'entier
	 * inférieur) des valeurs contenues dans le fichier.
	 *
	 * @param path le chemin vers le fichier à vérifier
	 * @return return la moyenne des valeurs
	 * @throws IOException           si une erreur de lecture survient
	 * @throws NumberFormatException si une ligne ne contient pas un entier valide
	 */
	public static long averageInFile(Path path) throws IOException {
		throw new UnsupportedOperationException("Not implemented yet");
	}


	/**
	 * Représente un couple (min, max) d'entiers, tels que min <= max.
	 *
	 * @param min plus petite des 2 valeurs
	 * @param max plus grande des 2 valeurs
	 */
	public record MinMax(int min, int max) {
		public MinMax {
			if (min > max) {
				throw new IllegalArgumentException("min sould be smaller than max");
			}
		}
	}
	
	/**
	 * Prend en entrée un fichier contenant deux entiers par ligne, un id et une
	 * valeur, séparés par un espace. Renvoie une liste des valeurs successive du minimum et du maximum 
	 * pour chaque occurence d'un dans le fichier.
	 *
	 * @param path le chemin vers le fichier à vérifier
	 * @return return la liste des couple min/max associé à l'id pour chaque ligne du fichier.
	 * @throws IOException           si une erreur de lecture survient
	 * @throws NumberFormatException si une ligne ne contient pas un entier valide
	 */
	public static List<MinMax> minMaxInFile(Path path) throws IOException {
		throw new UnsupportedOperationException("Not implemented yet");
	}

}