StatisticsService.java

package ui.entities.statistics.service;

import client.teavm.common.autoplay.DiskEventType;
import client.teavm.common.autoplay.KeyEventType;
import jakarta.persistence.EntityManager;
import libsidplay.components.keyboard.KeyTableEntry;
import ui.entities.statistics.*;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import java.util.random.RandomGenerator;
import java.util.stream.Collectors;

import static java.util.Comparator.comparingLong;
import static java.util.Optional.ofNullable;

/**
 * AutoPlay sessions, for example, are flagged as:
 * <table>
 *  <tr>
 *    <th>ID</th><th>event_time</th><th>event_type</th><th>jiffydos</th><th>session_id</th><th>disk_id</th><th>event_kind</th><th>key_table_entry</th>
 *  </tr>
 *  <tr>
 *    <td>5</td><td>0</td><td>START</td><td>true</td><td>731830e00f8777d8e13eced45522f167</td><td>731830e00f8777d8e13eced45522f167</td><td>DISK</td><td>null</td>
 *  </tr>
 *  <tr>
 *    <td>5</td><td>50</td><td>KEY_TYPED</td><td>true</td><td>731830e00f8777d8e13eced45522f167</td><td>null</td><td>KEY</td><td>SPACE</td>
 *  </tr>
 *  <tr>
 *    <td>6</td><td>100</td><td>CHANGE</td><td>true</td><td>731830e00f8777d8e13eced45522f167</td><td>731830e00f8777d8e13eced45522f168</td><td>DISK</td><td>null</td>
 *  </tr>
 *  <tr>
 *    <td>5</td><td>150</td><td>KEY_TYPED</td><td>true</td><td>731830e00f8777d8e13eced45522f167</td><td>null</td><td>KEY</td><td>SPACE</td>
 *  </tr>
 *  <tr>
 *    <td>7</td><td>200</td><td>CHANGE</td><td>true</td><td>731830e00f8777d8e13eced45522f167</td><td>731830e00f8777d8e13eced45522f169</td><td>DISK</td><td>null</td>
 *  </tr>
 *  <tr>
 *    <td>8</td><td>300</td><td>STOP</td><td>true</td><td>731830e00f8777d8e13eced45522f167</td><td>null</td><td>END</td><td>null</td>
 *  </tr>
 * </table>
 * This describes a typical demo using three disks where session id is always the first disk's MD5 and disk_id is the first, second, or third disk's MD5.
 * Event types are:
 * <pre>
 * START (first disk inserted)
 * KEY_TYPED (space-bar was hit)
 * CHANGE (second disk inserted)
 * KEY_TYPED (space-bar was hit)
 * CHANGE (third disk inserted)
 * STOP (demo stopped)
 * </pre>
 */
public class StatisticsService {

    private final EntityManager em;
    private final RandomGenerator random;

    public StatisticsService(EntityManager em) {
        this(em, ThreadLocalRandom.current());
    }

    StatisticsService(EntityManager em, RandomGenerator random) {
        this.em = em;
        this.random = random;
    }

    public void insertDiskEvent(String sessionId, boolean jiffyDos, String diskMd5, DiskEventType diskEventType, Long eventTime, String diskName, byte[] data) {
        try {
            if (em.isOpen()) {
                em.getTransaction().begin();

                Disk disk = em.find(Disk.class, diskMd5);

                if (disk == null) {
                    if (diskName == null || data == null) {
                        throw new IllegalStateException("Disk not found. Must provide name and data to create new a Disk.");
                    }
                    disk = new Disk();
                    disk.setMd5(diskMd5);
                    disk.setName(diskName);
                    disk.setData(data);
                    em.persist(disk);
                }

                DiskEvent event = new DiskEvent();
                event.setJiffyDos(jiffyDos);
                event.setSessionId(sessionId);
                event.setDisk(disk);
                event.setEventType(diskEventType.toEventType());
                event.setEventTime(eventTime);
                em.persist(event);

                em.getTransaction().commit();
            }
        } catch (Exception e) {
            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }
            throw e;
        }
    }

    /*
     * Finds the next disk for a given current disk MD5 and returns its MD5 plus average swap time in
     * seconds.
     */
    public Optional<NextDiskInfo> findNextDisk(String currentDiskMd5, boolean jiffyDos, Long id) {
        Optional<DiskEvent> optionalDiskEvent = getDiskEvent(currentDiskMd5, jiffyDos, id);
        if (!optionalDiskEvent.isPresent()) {
            return Optional.empty();
        }
        DiskEvent diskEvent = optionalDiskEvent.get();
        Long diskEventTime = diskEvent.getEventTime();

        return em.createQuery("SELECT e FROM DiskEvent e" +
                                " WHERE e.sessionId = :sessionId AND e.jiffyDos = :jiffyDos" +
                                " AND e.id > :id",
                        DiskEvent.class)
                .setParameter("sessionId", diskEvent.getSessionId())
                .setParameter("jiffyDos", jiffyDos)
                .setParameter("id", id)
                .getResultList().stream()
                // Search for next disk events in the future
                .filter(event -> event.getEventTime() > diskEventTime)
                // Find the closest future event
                .min(comparingLong(DiskEvent::getEventTime))
                .map(event -> new NextDiskInfo(
                        event.getJiffyDos(), event.getDisk().getName(),
                        ofNullable(event.getDisk().getData()).orElse(new byte[0]),
                        event.getEventTime() - diskEventTime, event.getId()));
    }

    public void insertKeyEvent(String sessionId, boolean jiffyDos, KeyTableEntry keyTableEntry, KeyEventType keyEventType, Long eventTime) {
        try {
            if (em.isOpen()) {
                em.getTransaction().begin();

                KeyEvent event = new KeyEvent();
                event.setJiffyDos(jiffyDos);
                event.setSessionId(sessionId);
                event.setKeyTableEntry(keyTableEntry);
                event.setEventType(keyEventType.toEventType());
                event.setEventTime(eventTime);
                em.persist(event);

                em.getTransaction().commit();
            }
        } catch (Exception e) {
            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }
            throw e;
        }
    }

    /*
     * Finds all key events for a given disk MD5 and jiffyDos flag, that happen in the future.
     */
    public List<KeyEventInfo> findKeyEvents(String currentDiskMd5, boolean jiffyDos) {
        Optional<DiskEvent> optionalDiskEvent = getDiskEvent(currentDiskMd5, jiffyDos);
        if (!optionalDiskEvent.isPresent()) {
            return Collections.emptyList();
        }
        DiskEvent diskEvent = optionalDiskEvent.get();
        Long diskEventTime = diskEvent.getEventTime();

        return em.createQuery("SELECT e FROM KeyEvent e" +
                                " WHERE e.sessionId = :sessionId AND e.jiffyDos = :jiffyDos",
                        KeyEvent.class)
                .setParameter("sessionId", diskEvent.getSessionId())
                .setParameter("jiffyDos", jiffyDos)
                .getResultList().stream()
                // Search for key events in the future
                .filter(event -> event.getEventTime() > diskEventTime)
                .map(event -> new KeyEventInfo(
                        KeyEventType.from(event.getEventType()),
                        event.getKeyTableEntry(),
                        event.getEventTime() - diskEventTime))
                .collect(Collectors.toList());
    }

    public void insertEndEvent(String sessionId, boolean jiffyDos, Long eventTime) {
        try {
            if (em.isOpen()) {
                em.getTransaction().begin();

                EndEvent event = new EndEvent();
                event.setJiffyDos(jiffyDos);
                event.setSessionId(sessionId);
                event.setEventType(EventType.STOP);
                event.setEventTime(eventTime);
                em.persist(event);

                em.getTransaction().commit();
            }
        } catch (Exception e) {
            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }
            throw e;
        }
    }

    /*
     * Find end event for a given disk MD5 and jiffyDos flag, that happen in the future.
     */
    public Optional<EndEventInfo> findEndEvent(String currentDiskMd5, boolean jiffyDos) {
        Optional<DiskEvent> optionalDiskEvent = getDiskEvent(currentDiskMd5, jiffyDos);
        if (!optionalDiskEvent.isPresent()) {
            return Optional.empty();
        }
        DiskEvent diskEvent = optionalDiskEvent.get();
        Long diskEventTime = diskEvent.getEventTime();

        return em.createQuery("SELECT e FROM EndEvent e" +
                                " WHERE e.sessionId = :sessionId AND e.jiffyDos = :jiffyDos",
                        EndEvent.class)
                .setParameter("sessionId", diskEvent.getSessionId())
                .setParameter("jiffyDos", jiffyDos)
                .getResultList().stream()
                // Search for key events in the future
                .filter(event -> event.getEventTime() > diskEventTime)
                .map(event -> new EndEventInfo(
                        event.getEventTime() - diskEventTime))
                .findFirst();
    }

    public void removeSessionEvents(String currentDiskMd5, boolean jiffyDos) {
        try {
            if (em.isOpen()) {
                em.getTransaction().begin();

                Optional<DiskEvent> optionalDiskEvent = getDiskEvent(currentDiskMd5, jiffyDos);
                if (!optionalDiskEvent.isPresent()) {
                    return;
                }
                DiskEvent diskEvent = optionalDiskEvent.get();

                em.createQuery("DELETE FROM StatEvent e" +
                                " WHERE e.sessionId = :sessionId AND e.jiffyDos = :jiffyDos")
                        .setParameter("sessionId", diskEvent.getSessionId())
                        .setParameter("jiffyDos", jiffyDos)
                        .executeUpdate();

                // global orphan cleanup across all events
                em.createQuery("DELETE FROM Disk d" +
                                " WHERE NOT EXISTS (" +
                                " SELECT e FROM DiskEvent e WHERE e.disk = d)")
                        .executeUpdate();

                em.getTransaction().commit();
            }
        } catch (Exception e) {
            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }
            throw e;
        }
    }

    public Optional<NextDiskInfo> findRandomStartDisk() {
        List<DiskEvent> startDiskEvents = em.createQuery("SELECT e FROM DiskEvent e" +
                                " WHERE e.eventType = 'START'",
                        DiskEvent.class)
                .getResultList();
        if (startDiskEvents.isEmpty()) {
            return Optional.empty();
        }
        // Extra loader modes or training records must not increase a demo's probability.
        List<List<DiskEvent>> demos = new ArrayList<>(startDiskEvents.stream()
                .collect(Collectors.groupingBy(event -> event.getDisk().getMd5())).values());
        List<DiskEvent> trainingRecords = demos.get(random.nextInt(demos.size()));
        DiskEvent event = trainingRecords.get(random.nextInt(trainingRecords.size()));

        return Optional.of(new NextDiskInfo(
                event.getJiffyDos(),
                event.getDisk().getName(),
                ofNullable(event.getDisk().getData()).orElse(new byte[0]),
                event.getEventTime(), event.getId()));
    }

    private Optional<DiskEvent> getDiskEvent(String currentDiskMd5, boolean jiffyDos) {
        return getDiskEvent(currentDiskMd5, jiffyDos, 0L);
    }

    /**
     * Retrieves an optional {@link DiskEvent} for the specified disk MD5 and jiffyDos flag. Can be used to find the
     * current session ID and when the disk has been inserted.
     *
     * @param currentDiskMd5 the MD5 hash of the disk to match in the query
     * @param jiffyDos       a boolean flag indicating whether the fastloader JiffyDos has been used
     * @return an {@link Optional} containing the matching {@link DiskEvent} if found
     */
    private Optional<DiskEvent> getDiskEvent(String currentDiskMd5, boolean jiffyDos, Long id) {
        return em.createQuery("SELECT e FROM DiskEvent e WHERE e.disk.md5 = :diskMd5 AND e.jiffyDos = :jiffyDos" +
                                " AND e.id >= :id",
                        DiskEvent.class)
                .setParameter("diskMd5", currentDiskMd5)
                .setParameter("jiffyDos", jiffyDos)
                .setParameter("id", id)
                .setMaxResults(1)
                .getResultList().stream().findFirst();
    }
}