import asyncio
import os
import sys
import logging
import signal

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

async def mock_service(stop_event):
    logging.info("Mock service started.")
    try:
        while not stop_event.is_set():
            await asyncio.sleep(0.1)
    except asyncio.CancelledError:
        logging.info("Mock service cancelled.")
    finally:
        logging.info("Mock service cleaned up resources.")

async def main():
    loop = asyncio.get_running_loop()
    stop_event = asyncio.Event()

    def handle_signal():
        logging.info("Signal handler triggered.")
        stop_event.set()

    if sys.platform != "win32":
        loop.add_signal_handler(signal.SIGTERM, handle_signal)
        loop.add_signal_handler(signal.SIGINT, handle_signal)
        # On Linux/Unix, simulate sending SIGTERM to ourselves after 1 second
        async def simulate_sigterm_linux():
            await asyncio.sleep(1.0)
            logging.info("Simulating SIGTERM signal on Linux...")
            os.kill(os.getpid(), signal.SIGTERM)
        asyncio.create_task(simulate_sigterm_linux())
    else:
        # On Windows, we simulate it via a self-sent task after 1 second
        async def simulate_sigterm():
            await asyncio.sleep(1.0)
            logging.info("Simulating SIGTERM signal on Windows...")
            stop_event.set()
        asyncio.create_task(simulate_sigterm())

    service_task = asyncio.create_task(mock_service(stop_event))

    async def wait_for_stop():
        await stop_event.wait()
        logging.info("Stop monitor: Triggering cleanup...")

    stop_monitor = asyncio.create_task(wait_for_stop())

    try:
        await asyncio.gather(service_task, stop_monitor)
        logging.info("All tasks completed gracefully.")
        sys.exit(0)
    except Exception as e:
        logging.error(f"Error during runtime: {e}")
        sys.exit(1)

if __name__ == "__main__":
    asyncio.run(main())