#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "DebugCore.h"
#include "DebugService.h"
#include "DebugBrokerWrapper.h"
#include "TcpLogger.h"
#include "ConfigurationDatabase.h"
#include "ObjectRegistryDatabase.h"
#include "GlobalObjectsDatabase.h"

namespace MARTe {

void TestTcpLogger() {
    printf("Stability Logger Tests...\n");
    TcpLogger logger;
    ConfigurationDatabase config;
    config.Write("Port", (uint32)0); // Random port
    assert(logger.Initialise(config));
}

class DebugServiceTest {
public:
    static void TestAll() {
        printf("Stability Logic Tests...\n");
        ObjectRegistryDatabase::Instance()->Purge();
        
        DebugService service;
        assert(service.traceBuffer.Init(1024 * 1024));

        ConfigurationDatabase cfg;
        cfg.Write("ControlPort", (uint32)0); 
        cfg.Write("StreamPort", (uint32)0);
        cfg.Write("SuppressTimeoutLogs", (uint32)1);
        assert(service.Initialise(cfg));

        // 1. Signal logic
        uint32 val = 0;
        service.RegisterSignal(&val, UnsignedInteger32Bit, "X.Y.Z", 0, 1);
        assert(service.TraceSignal("Z", true) == 1);
        assert(service.ForceSignal("Z", "123") == 1);
        
        uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
        service.ProcessSignal(service.signals[0], 4, ts);
        assert(val == 123);
        service.UnforceSignal("Z");

        // 2. Commands
        service.HandleCommand("TREE", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("DISCOVER", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("CONFIG", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("PAUSE", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("RESUME", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("LS /", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("INFO X.Y.Z", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("MSG DebugService DummyFunc 0 K=V", NULL_PTR(BasicTCPSocket*));
        
        // 3. Broker Active Status
        volatile bool active = false;
        Vec<uint32> indices;
        Vec<uint32> sizes;
        FastPollingMutexSem mutex;
        DebugSignalInfo* ptrs[1] = { service.signals[0] };
        volatile bool anyBreak = false;
        Vec<uint32> breakIdx;
        service.RegisterBroker(ptrs, 1, NULL_PTR(MemoryMapBroker*), &active, &indices, &sizes, &mutex, &anyBreak, &breakIdx);
        service.UpdateBrokersActiveStatus();
        assert(active == true);
        assert(indices.Size() == 1);
        assert(indices[0] == 0);

        // Helper Process
        DebugBrokerHelper::Process(&service, ptrs, indices, sizes, mutex, &anyBreak, &breakIdx);

        // 4. Step / per-thread filter
        // STEP with no thread filter — all threads can consume
        service.Step(2u, NULL_PTR(const char8 *));
        assert(!service.IsPaused());
        assert(service.stepRemaining == 2u);
        service.ConsumeStepIfNeeded("GAM1", "ThreadA");
        assert(service.stepRemaining == 1u);
        assert(!service.IsPaused());
        service.ConsumeStepIfNeeded("GAM1", "ThreadB");
        assert(service.stepRemaining == 0u);
        assert(service.IsPaused());
        assert(service.pausedAtGam == "GAM1");

        // STEP with a thread filter — only matching thread consumes
        service.Step(2u, "ThreadA");
        assert(!service.IsPaused());
        assert(service.stepThreadFilter == "ThreadA");
        // ThreadB should be ignored
        service.ConsumeStepIfNeeded("GAMB", "ThreadB");
        assert(service.stepRemaining == 2u);  // unchanged
        assert(!service.IsPaused());
        // ThreadA consumes both credits
        service.ConsumeStepIfNeeded("GAMA1", "ThreadA");
        assert(service.stepRemaining == 1u);
        assert(!service.IsPaused());
        service.ConsumeStepIfNeeded("GAMA2", "ThreadA");
        assert(service.stepRemaining == 0u);
        assert(service.IsPaused());
        assert(service.pausedAtGam == "GAMA2");

        // STEP with unknown thread (NULL threadName arg to ConsumeStep) is also filtered out
        service.Step(1u, "ThreadA");
        service.ConsumeStepIfNeeded("X", NULL_PTR(const char8 *));
        assert(service.stepRemaining == 1u);  // not consumed
        service.SetPaused(false);
        service.Step(0u, NULL_PTR(const char8 *));

        // 5. VALUE command (NULL client — smoke test, no crash)
        service.HandleCommand("VALUE X.Y.Z", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("VALUE NoSuchSignal", NULL_PTR(BasicTCPSocket*));
        service.HandleCommand("STEP 1 ThreadA", NULL_PTR(BasicTCPSocket*));
        assert(service.stepThreadFilter == "ThreadA");
        service.HandleCommand("STEP 3", NULL_PTR(BasicTCPSocket*));
        assert(service.stepThreadFilter.Size() == 0u);
    }
};

}

#include <signal.h>

void timeout_handler(int sig) {
    printf("Test timed out!\n");
    _exit(1);
}

int main() {
    signal(SIGALRM, timeout_handler);
    alarm(10); 
    printf("--- MARTe2 Debug Suite COVERAGE V30 ---\n");
    MARTe::TestTcpLogger();
    MARTe::DebugServiceTest::TestAll();
    printf("\nCOVERAGE V30 PASSED!\n");
    return 0;
}