Status.java

package libsidutils.status;

import libsidplay.HardwareEnsemble;
import libsidplay.common.*;
import libsidplay.common.Event.Phase;
import libsidplay.components.c1530.Datasette;
import libsidplay.components.cart.Cartridge;
import libsidplay.config.IEmulationSection;
import libsidplay.sidtune.SidTune;
import libsidplay.sidtune.SidTuneInfo;
import sidplay.audio.AudioDriver;
import sidplay.player.Timer;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Optional;
import java.util.function.BooleanSupplier;
import java.util.function.Function;

import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;
import static libsidplay.sidtune.SidTune.RESET;
import static libsidutils.IOUtils.getPhysicalSize;

public class Status {

    private final HardwareEnsemble hardwareEnsemble;
    private final SidTune tune;
    private final SIDBuilder sidBuilder;
    private final AudioDriver audioDriver;
    private final Function<SidTune, String> recordingFilenameProvider;
    private final Timer timer;
    private final BooleanSupplier psid64Function;
    private final BooleanSupplier stereoSniffedFunction;
    private final Function<String, String> resourceBundle;

    public Status(HardwareEnsemble hardwareEnsemble, SidTune tune, SIDBuilder sidBuilder, AudioDriver audioDriver,
                  Function<SidTune, String> recordingFilenameProvider, Timer timer, BooleanSupplier psid64Function,
                  BooleanSupplier stereoSniffedFunction, Function<String, String> resourceBundle) {
        this.hardwareEnsemble = hardwareEnsemble;
        this.tune = tune;
        this.sidBuilder = sidBuilder;
        this.audioDriver = audioDriver;
        this.recordingFilenameProvider = recordingFilenameProvider;
        this.timer = timer;
        this.psid64Function = psid64Function;
        this.stereoSniffedFunction = stereoSniffedFunction;
        this.resourceBundle = resourceBundle;
    }

    public String determineVideoNorm() {
        return hardwareEnsemble.getC64().getClock().name();
    }

    public String determineVicModel() {
        return hardwareEnsemble.getC64().getConfiguredVicModel().name();
    }

    public String determineChipModels() {
        IEmulationSection emulation = hardwareEnsemble.getConfig().getEmulationSection();

        StringBuilder result = new StringBuilder();
        determineChipModel(result, emulation, 0);
        if (SidTune.isSIDUsed(emulation, tune, 1)) {
            result.append("+");
            determineChipModel(result, emulation, 1);
            if (SidTune.isSIDUsed(emulation, tune, 2)) {
                result.append("+");
                determineChipModel(result, emulation, 2);
                andNMore(emulation, result);
            }
        }
        return result.toString();
    }

    private void determineChipModel(StringBuilder result, IEmulationSection emulationSection, int sidNum) {
        ChipModel chipModel = ChipModel.getChipModel(emulationSection, tune, sidNum);
        int sidBase = SidTune.getSIDAddress(emulationSection, tune, sidNum);
        if (sidBase != SIDChip.DEF_BASE_ADDRESS) {
            result.append(String.format("%s(at 0x%04x)", chipModel, sidBase));
        } else {
            result.append(chipModel);
        }
    }

    public String determineEmulations() {
        IEmulationSection emulation = hardwareEnsemble.getConfig().getEmulationSection();

        StringBuilder result = new StringBuilder();
        switch (emulation.getEngine()) {
            case EMULATION:
                result.append(Emulation.getEmulation(emulation, 0).name());
                if (SidTune.isSIDUsed(emulation, tune, 1)) {
                    result.append("+");
                    result.append(Emulation.getEmulation(emulation, 1).name());
                    if (SidTune.isSIDUsed(emulation, tune, 2)) {
                        result.append("+");
                        result.append(Emulation.getEmulation(emulation, 2).name());
                        andNMore(emulation, result);
                    }
                }
                break;
            case HARDSID:
            case SIDBLASTER:
            case EXSID:
            case USBSID:
            case HARDSID_DLL:
                Integer deviceCount = getHardwareSIDBuilderInfo(HardwareSIDBuilder::getDeviceCount, null);
                if (deviceCount != null) {
                    determineEmulation(result, emulation, 0);
                    if (SidTune.isSIDUsed(emulation, tune, 1)) {
                        result.append("+");
                        determineEmulation(result, emulation, 1);
                        if (SidTune.isSIDUsed(emulation, tune, 2)) {
                            result.append("+");
                            determineEmulation(result, emulation, 2);
                        }
                    }
                    result.append(" ");
                    result.append(String.format(resourceBundle.apply("DEVICES"), deviceCount));
                    break;
                }
                // $FALL-THROUGH$
            case NETSID:
                result.append(emulation.getEngine().name());
                if (SidTune.isSIDUsed(emulation, tune, 1)) {
                    result.append("+");
                    result.append(emulation.getEngine().name());
                    if (SidTune.isSIDUsed(emulation, tune, 2)) {
                        result.append("+");
                        result.append(emulation.getEngine().name());
                    }
                }
                break;
            default:
                break;
        }
        return result.toString();
    }

    private void andNMore(IEmulationSection emulation, StringBuilder result) {
        int sidNum = 3;
        while (sidNum < MAX_SIDS && SidTune.isSIDUsed(emulation, tune, sidNum)) {
            sidNum++;
        }
        if (sidNum > 3) {
            result.append("+");
            result.append(sidNum - 3);
            result.append(" ");
            result.append(resourceBundle.apply("MORE"));
        }
    }

    private void determineEmulation(StringBuilder result, IEmulationSection emulationSection, int sidNum) {
        Integer deviceId = getHardwareSIDBuilderInfo(sidBuilder -> sidBuilder.getDeviceId(sidNum), null);
        String deviceName = getHardwareSIDBuilderInfo(sidBuilder -> sidBuilder.getDeviceName(sidNum), null);
        ChipModel deviceChipModel = getHardwareSIDBuilderInfo(sidBuilder -> sidBuilder.getDeviceChipModel(sidNum),
                null);
        if (deviceId != null) {
            result.append(String.format(resourceBundle.apply("DEVICE"), emulationSection.getEngine().name(),
                    deviceId + 1, Optional.ofNullable(deviceChipModel).orElse(ChipModel.AUTO),
                    Optional.ofNullable(deviceName).orElse("")));
        } else {
            result.append(emulationSection.getEngine().name());
        }
    }

    public String determineTuneSpeed() {
        double tuneSpeed = hardwareEnsemble.getC64().determineTuneSpeed();
        if (tuneSpeed > 0) {
            return (String.format("%s: %.1fx", resourceBundle.apply("SPEED"), tuneSpeed));
        }
        return "";
    }

    public String determineSong() {
        if (tune != RESET) {
            SidTuneInfo info = tune.getInfo();
            if (info.getSongs() > 1) {
                return String.format("%s: %d/%d", resourceBundle.apply("SONG"), info.getCurrentSong(), info.getSongs());
            }
        }
        return "";
    }

    public String determineDiskActivity(boolean showTrack) {
        if (!hardwareEnsemble.isFloppyPowerOn()) {
            return "";
        }
        if (showTrack) {
            String floppyType = hardwareEnsemble.getFloppyType().name();
            if (hardwareEnsemble.isFloppyMotorOn()) {
                int halfTrack = hardwareEnsemble.getFloppyHalfTrack();
                return String.format("%s %s: %02d", floppyType, resourceBundle.apply("FLOPPY_TRACK"), halfTrack >> 1);
            }
            return floppyType;
        }
        return hardwareEnsemble.isFloppyMotorOn() ? "*" : "";
    }

    public String determineTapeActivity(boolean showCounter) {
        Datasette datasette = hardwareEnsemble.getDatasette();
        if (showCounter) {
            if (datasette.getMotor()) {
                return String.format("%s: %03d", resourceBundle.apply("DATASETTE_COUNTER"), datasette.getCounter());
            }
        } else {
            return datasette.getMotor() ? "+" : "";
        }
        return "";
    }

    public String determineCartridge() {
        Cartridge cartridge = hardwareEnsemble.getC64().getCartridge();
        if (cartridge != null) {
            return cartridge.toString();
        }
        return "";
    }

    public String determineHeap() {
        StringBuilder result = new StringBuilder();
        Runtime runtime = Runtime.getRuntime();
        result.append(resourceBundle.apply("MEMORY"));
        result.append(": ");
        result.append(getPhysicalSize(runtime.totalMemory() - runtime.freeMemory()));
        result.append("/");
        result.append(getPhysicalSize(runtime.maxMemory()));
        return result.toString();
    }

    public String determineTime(boolean showMillis) {
        double timeInSeconds = time();
        if (showMillis) {
            return String.format("%s: %s", resourceBundle.apply("TIME"),
                    new SimpleDateFormat("mm:ss.SSS").format(new Date((long) (timeInSeconds * 1000))));
        } else {
            return new SimpleDateFormat("mm:ss").format(new Date((long) (timeInSeconds * 1000)));
        }
    }

    public String determineSongLength(boolean showMillis) {
        double songLength = timer.getEnd();
        if (songLength > 0) {
            // song length well-known?
            if (showMillis) {
                return new SimpleDateFormat("mm:ss.SSS").format(new Date((long) (songLength * 1000)));
            } else {
                return new SimpleDateFormat("mm:ss").format(new Date((long) (songLength * 1000)));
            }
        }
        return "";
    }

    public String determineRecording() {
        if (audioDriver.isRecording()) {
            return String.format("%s: %s (%s)", resourceBundle.apply("RECORDING_FILENAME"),
                    recordingFilenameProvider.apply(tune),
                    getPhysicalSize(new File(recordingFilenameProvider.apply(tune)).length()));
        }
        return "";
    }

    public String determinePSID64() {
        if (psid64Function.getAsBoolean()) {
            return "PSID64";
        }
        return "";
    }

    public String determineStereoSniffed() {
        if (stereoSniffedFunction.getAsBoolean()) {
            return "SNIF";
        }
        return "";
    }

    private <T> T getHardwareSIDBuilderInfo(final Function<HardwareSIDBuilder, T> function,
                                            final T defaultValue) {
        return sidBuilder instanceof HardwareSIDBuilder ? function.apply((HardwareSIDBuilder) sidBuilder)
                : defaultValue;
    }

    private double time() {
        final EventScheduler c = hardwareEnsemble.getC64().getEventScheduler();
        long initDelay = SidTune.getInitDelay(tune);
        return (c.getTime(Phase.PHI2) - initDelay) / c.getCyclesPerSecond();
    }

    public String createStatusLine(boolean verbose, String playerId) {
        if (verbose) {
            String determineTapeActivity = determineTapeActivity(true);
            String determineDiskActivity = determineDiskActivity(true);
            String determineSongLength = determineSongLength(true);
            String determineRecording = determineRecording();
            String determinePSID64 = determinePSID64();
            String determineStereoSniffed = determineStereoSniffed();
            String determineCartridge = determineCartridge();
            String determineTuneSpeed = determineTuneSpeed();
            String determineSong = determineSong();

            return determineVideoNorm() +
                    ", " +
                    determineVicModel() +
                    ", " +
                    determineChipModels() +
                    ", " +
                    determineEmulations() +
                    playerId +
                    (determinePSID64.isEmpty() ? "" : ", " + determinePSID64) +
                    (determineStereoSniffed.isEmpty() ? "" : ", " + determineStereoSniffed) +
                    (determineCartridge.isEmpty() ? "" : ", " + determineCartridge) +
                    (determineTuneSpeed.isEmpty() ? "" : ", " + determineTuneSpeed) +
                    (determineSong.isEmpty() ? "" : ", " + determineSong) +
                    ", " +
                    hardwareEnsemble.getC64().getModel() +
                    (determineDiskActivity.isEmpty() ? "" : ", " + determineDiskActivity) +
                    (determineTapeActivity.isEmpty() ? "" : ", " + determineTapeActivity) +
                    ", " +
                    determineTime(true) +
                    (determineSongLength.isEmpty() ? "" : "/" + determineSongLength) +
                    (determineRecording.isEmpty() ? "" : ", " + determineRecording);
        } else {
            String determinePSID64 = determinePSID64();
            String determineStereoSniffed = determineStereoSniffed();
            String determineCartridge = determineCartridge();
            String floppyType = hardwareEnsemble.isFloppyPowerOn() ? hardwareEnsemble.getFloppyType().name() : "";
            String activity = determineTapeActivity(false) + determineDiskActivity(false);

            return determineTime(false) +
                    ", " +
                    determineVideoNorm() +
                    ", " +
                    determineVicModel() +
                    ", " +
                    determineChipModels() +
                    ", " +
                    determineEmulations() +
                    playerId +
                    (determinePSID64.isEmpty() ? "" : ", " + determinePSID64) +
                    (determineStereoSniffed.isEmpty() ? "" : ", " + determineStereoSniffed) +
                    (determineCartridge.isEmpty() ? "" : ", " + determineCartridge) +
                    ", " +
                    hardwareEnsemble.getC64().getModel() +
                    (floppyType.isEmpty() ? "" : ", " + floppyType) +
                    (activity.isEmpty() ? "" : ", " + activity);
        }
    }
}