private static final String FILE = "./measurements.txt";

private static final int MAX_LENGTH_LINE = 255;

private static final int MAX_BUFFER = 1024 * 8;

private static boolean DEBUG = false;

public static int DECENAS[] = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90 };

public static int CENTENAS[] = { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 };

public record Particion(long offset, long size) {

}

/*

* Divide el archivo segun el nro de cores de la PC

* La division se debe recalcular hasta encontrar un \n o \r (enter o return)

*/

public static List<Particion> dividirArchivo(File archivo) throws IOException {

var particiones = new ArrayList<Particion>();

var buffer = new byte[MAX_LENGTH_LINE];

var length = archivo.length();

int cores = Runtime.getRuntime().availableProcessors();

var sizeParticion = length / cores;

if (sizeParticion > MAX_BUFFER) {

var ini = 0l;

try (var rfile = new RandomAccessFile(archivo, "r")) {

for (;;) {

var size = sizeParticion;

var pos = ini + size;

if (pos > length) {

pos = length - 1;

size = length - ini;

}

rfile.seek(pos);

int count = rfile.read(buffer);

if (count == -1) {

break;

}

for (int i = 0; i < count; i++) {

size++;

if (buffer[i] == '\n' || buffer[i] == '\r') {

break;

}

}

var particion = new Particion(ini, size);

particiones.add(particion);

if (count != buffer.length) {

break;

}

ini += size;

}

}

}

else {

particiones.add(new Particion(0, length));

}

return particiones;

}

/*

* cambiar el locale para que el separador decimal sea punto y no coma

* crear un hilo por cada particion

* totalizar las mediciones por cada hilo

* ordenar y mostrar

*/

public static void main(String[] args) throws InterruptedException, IOException {

Locale.setDefault(Locale.US);

var startTime = System.nanoTime();

var archivo = new File(FILE);

var tareas = new ArrayList<Thread>();

var totalMediciones = new HashMap<Index, Medicion>();

var particiones = dividirArchivo(archivo);

for (var p : particiones) {

var hilo = Thread.ofVirtual().start(() -> {

try (var miTarea = new MiTarea(archivo, p)) {

var mediciones = miTarea.calcularMediciones();

for (var entry : mediciones.entrySet()) {

Medicion medicion;

synchronized (totalMediciones) {

medicion = totalMediciones.get(entry.getKey());

if (medicion == null) {

totalMediciones.put(entry.getKey(), entry.getValue());

medicion = entry.getValue();

}

}

synchronized (medicion) {

if (!medicion.equals(entry.getValue())) {

var otraMed = entry.getValue();

medicion.update(otraMed.count, otraMed.tempMin, otraMed.tempMax, otraMed.tempSum);

}

}

}

}

catch (IOException e) {

System.exit(-1);

}

});

tareas.add(hilo);

}

Comparator<Map.Entry<Index, Medicion>> comparar = (a, b) -> {

return a.getValue().getNombreEstacion().compareTo(b.getValue().getNombreEstacion());

};

for (var hilo : tareas) {

hilo.join();

}

var result = totalMediciones.entrySet().stream()//

.sorted(comparar)

.map(e -> e.getValue().toString())//

.collect(Collectors.joining(", "));

System.out.println("{" + result + "}");

if (DEBUG) {

System.out.println("Total: " + (System.nanoTime() - startTime) / 1000000 + "ms");

}

}

/*

* Clase Index para reutilizar al realizar un get en el Map

*/

static class Index {

private int hash;

private byte[] data;

private int fromIndex;

private int length;

public Index() {

this.hash = 0;

}

public Index(byte data[], int fromIndex, int length) {

this.data = data;

this.fromIndex = fromIndex;

this.length = length;

this.hash = calcHashCode(length, data, fromIndex, length);

}

public void setData(byte data[], int fromIndex, int length) {

this.data = data;

this.fromIndex = fromIndex;

this.length = length;

this.hash = calcHashCode(length, data, fromIndex, length);

}

/*

* Calcula el hash de cada estacion,

* variation of Daniel J Bernstein's algorithm

*/

private int calcHashCode(int result, byte[] a, int fromIndex, int length) {

int end = fromIndex + length;

for (int i = fromIndex; i < end; i++) {

result = ((result << 5) + result) ^ a[i];

}

return result;

}

@Override

public int hashCode() {

return hash;

}

@Override

public boolean equals(Object obj) {

if (this == obj) {

return true;

}

var otro = (Index) obj;

return Arrays.equals(this.data, this.fromIndex, this.fromIndex + this.length, otro.data, otro.fromIndex,

otro.fromIndex + otro.length);

}

}

/*

* Clase para procesar el archivo a la particion que corresponde

* RandomAccessFile permite dezplazar el puntero de lectura del archivo

* Tenemos un Map para guardar las estadisticas y un map para guardar los

* nombres de las estaciones

*/

static class MiTarea implements AutoCloseable {

private final RandomAccessFile rFile;

private long maxRead;

private Index index = new Index();

private Map<Index, Medicion> mediciones = new HashMap<>();

public MiTarea(File file, Particion particion) throws IOException {

rFile = new RandomAccessFile(file, "r");

maxRead = particion.size;

rFile.seek(particion.offset);

}

@Override

public void close() throws IOException {

rFile.close();

}

/*

* Lee solo su particion

* Divide el buffer por lineas usando los separadores \n o \r (enter o return)

* obtiene la posicion de separacion ";" de la estacion y su temperatura

* calcula el hash, convierte a double y actualiza las estadisticas

*/

public Map<Index, Medicion> calcularMediciones() throws IOException {

var buffer = new byte[MAX_BUFFER];// buffer para lectura en el archivo

var rest = new byte[MAX_LENGTH_LINE];// Resto que sobra en cada lectura del buffer

var lenRest = 0;// Longitud que sobró en cada lectura del buffer

var totalRead = 0l; // Total bytes leidos

for (;;) {

if (totalRead == maxRead) {

break;

}

long numBytes = rFile.read(buffer);

if (numBytes == -1) {

break;

}

numBytes = totalRead + numBytes > maxRead ? maxRead - totalRead : numBytes;

totalRead += numBytes;

int pos = 0;

int len = 0;

int idx = 0;

int semicolon = 0;

while (pos < numBytes) {

var b = buffer[pos];

if (b == '\n' || b == '\r') {

if (lenRest > 0) {

// concatenamos el sobrante anterior con la nueva linea

System.arraycopy(buffer, idx, rest, lenRest, len);

len += lenRest;

semicolon = buscarSemicolon(rest, len);

lenRest = 0;

updateMediciones(rest, 0, semicolon);

}

else {

updateMediciones(buffer, idx, semicolon);

}

idx = pos + 1;

len = 0;

semicolon = 0;

}

else {

if (b == ';') {

semicolon = len;

}

len++;

}

pos++;

}

if (len > 0) {

System.arraycopy(buffer, idx, rest, 0, len);

lenRest = len;

}

}

return mediciones;

}

/*

* Buscamos en reverso ya que el ; esta mas cerca de numero que la estacion

* ademas el minimo numero 0.0 asi que quitamos tres mas

*/

public int buscarSemicolon(byte data[], int len) {

for (int i = len - 4; i >= 0; i--) {

if (data[i] == ';') {

return i;

}

}

return 0;

}

/*

* Busca una medicion por su hash y crea o actualiza la temperatura

*/

public void updateMediciones(byte data[], int pos, int semicolon) {

var temp = strToInt(data, pos, semicolon);

index.setData(data, pos, semicolon);

var medicion = mediciones.get(index);

if (medicion == null) {

var estacion = new byte[semicolon];

System.arraycopy(data, pos, estacion, 0, semicolon);

medicion = new Medicion(estacion, 1, temp, temp, temp);

mediciones.put(new Index(estacion, 0, semicolon), medicion);

}

else {

medicion.update(1, temp, temp, temp);

}

}

/*

* convierte de un arreglo de bytes a integer

*/

public int strToInt(byte linea[], int idx, int posSeparator) {

int pos = idx + posSeparator + 1;

boolean esNegativo = linea[pos] == '-';

pos = esNegativo ? pos + 1 : pos;

int number = linea[pos + 1] == '.' ? DECENAS[(linea[pos] - 48)] + linea[pos + 2] - 48

: CENTENAS[(linea[pos] - 48)] + DECENAS[(linea[pos + 1] - 48)] + (linea[pos + 3] - 48);

return esNegativo ? -number : number;

}

}

/*

* Clase para reservar las estadisticas por estacion

*/

static class Medicion {

private int count;

private int tempMin;

private int tempMax;

private int tempSum;

private byte estacion[];

private String nombreEstacion;

public Medicion(byte estacion[], int count, int tempMin, int tempMax, int tempSum) {

super();

this.estacion = estacion;

this.count = count;

this.tempMin = tempMin;

this.tempMax = tempMax;

this.tempSum = tempSum;

}

public void update(int count, int tempMin, int tempMax, int tempSum) {

this.count += count;

this.tempMin = Math.min(tempMin, this.tempMin);

this.tempMax = Math.max(tempMax, this.tempMax);

this.tempSum += tempSum;

}

public double round(double number) {

return Math.round(number) / 10.0;

}

public String getNombreEstacion() {

if (nombreEstacion == null) {

nombreEstacion = new String(estacion);

}

return nombreEstacion;

}

@Override

public String toString() {

var min = round(tempMin);

var mid = round(1.0 * tempSum / count);

var max = round(tempMax);

var nombre = getNombreEstacion();

return "%s=%.1f/%.1f/%.1f".formatted(nombre, min, mid, max);

}

}