using UnityEngine;
using GameLovers.Services;

public class GameBootstrap : MonoBehaviour
{
    void Awake()
    {
        // Create service instances
        var messageBroker = new MessageBrokerService();
        var tickService = new TickService();
        var dataService = new DataService();
        
        // Bind to MainInstaller (interfaces only)
        MainInstaller.Bind<IMessageBrokerService>(messageBroker);
        MainInstaller.Bind<ITickService>(tickService);
        MainInstaller.Bind<IDataService>(dataService);
    }
    
    void OnDestroy()
    {
        // Clean up on shutdown
        MainInstaller.CleanDispose<ITickService>();
        MainInstaller.Clean();
    }
}

using GameLovers.Services;

public class PlayerController
{
    public PlayerController()
    {
        // Resolve services
        var messageBroker = MainInstaller.Resolve<IMessageBrokerService>();
        
        // Subscribe to events
        messageBroker.Subscribe<PlayerDamagedMessage>(OnPlayerDamaged);
    }
    
    private void OnPlayerDamaged(PlayerDamagedMessage message)
    {
        // Handle event
    }
}

// Define messages as structs implementing IMessage
public struct PlayerDamagedMessage : IMessage
{
    public int PlayerId;
    public float Damage;
}

// Bind services (interfaces only)
MainInstaller.Bind<IMessageBrokerService>(new MessageBrokerService());
MainInstaller.Bind<IDataService>(new DataService());

// Resolve services
var messageBroker = MainInstaller.Resolve<IMessageBrokerService>();

// Safe resolve (doesn't throw)
if (MainInstaller.TryResolve<IDataService>(out var dataService))
{
    dataService.SaveData();
}

// Clean up
MainInstaller.Clean<IMessageBrokerService>(); // Remove single binding
MainInstaller.CleanDispose<ITickService>();   // Dispose + remove
MainInstaller.Clean();                         // Clear all bindings

// Define messages
public struct EnemyDefeatedMessage : IMessage
{
    public int EnemyId;
    public Vector3 Position;
}

var broker = new MessageBrokerService();

// Subscribe (instance methods only)
broker.Subscribe<EnemyDefeatedMessage>(OnEnemyDefeated);

// Publish
broker.Publish(new EnemyDefeatedMessage { EnemyId = 42, Position = Vector3.zero });

// Use PublishSafe for chain subscriptions
broker.PublishSafe(new EnemyDefeatedMessage { EnemyId = 42 });

// Unsubscribe
broker.Unsubscribe<EnemyDefeatedMessage>(this);    // This subscriber only
broker.Unsubscribe<EnemyDefeatedMessage>();        // All subscribers
broker.UnsubscribeAll(this);                        // All messages for this subscriber

public class GameController : ITickable, IDisposable
{
    private readonly ITickService _tickService;
    
    public GameController()
    {
        _tickService = new TickService();
        _tickService.Add(this);              // Update callback
        _tickService.AddFixed(this);         // FixedUpdate callback
        _tickService.Add(this, 0.1f);        // Buffered: every 0.1 seconds
    }
    
    public void OnTick(float deltaTime, double time)
    {
        // Called every frame (or at specified interval)
    }
    
    public void Dispose()
    {
        _tickService.Remove(this);
        _tickService.Dispose();
    }
}

var coroutineService = new CoroutineService();

// Start coroutine with completion callback
coroutineService.StartCoroutine(MyRoutine(), () => Debug.Log("Done!"));

// Delayed execution
coroutineService.StartDelayCall(2f, () => Debug.Log("2 seconds later"));

// Get coroutine reference
var asyncCoroutine = coroutineService.StartCoroutine(LongTask());
if (asyncCoroutine.IsRunning)
{
    coroutineService.StopCoroutine(asyncCoroutine);
}

IEnumerator MyRoutine()
{
    yield return new WaitForSeconds(1f);
    Debug.Log("Coroutine step");
}

var poolService = new PoolService();

// Create pools
var bulletPool = new GameObjectPool<Bullet>(bulletPrefab, initialSize: 50);
poolService.AddPool(bulletPool);

// Spawn/Despawn
var bullet = poolService.Spawn<Bullet>();
poolService.Despawn(bullet);

// Spawn with data (implement IPoolEntitySpawn<T>)
var bullet = poolService.Spawn<Bullet, BulletData>(new BulletData { Damage = 100 });

// Direct pool access
var pool = poolService.GetPool<Bullet>();
pool.DespawnAll();

[Serializable]
public class PlayerData
{
    public string Name;
    public int Level;
}

var dataService = new DataService();

// Save
var player = new PlayerData { Name = "Hero", Level = 10 };
dataService.AddOrReplaceData("player", player);
await dataService.SaveData();

// Load
await dataService.LoadData();
var loaded = dataService.GetData<PlayerData>("player");

// Create with seed
var rngData = RngService.CreateRngData(seed: 12345);
var rng = new RngService(rngData);

// Generate values
int randomInt = rng.Next;                    // 0 to int.MaxValue
floatP randomFloat = rng.Nextfloat;          // 0 to floatP.MaxValue
int ranged = rng.Range(1, 100);              // 1-99 (exclusive max)
floatP rangedFloat = rng.Range(0f, 1f);      // 0-1 (inclusive max)

// Peek without advancing
int peeked = rng.Peek;                       // Same value on repeated calls

// Save/restore state for determinism
int savedCount = rng.Counter;
// ... generate some values ...
rng.Restore(savedCount);                     // Restore to saved state

using GameLovers.Services;

// Load version data (call once at startup)
await VersionServices.LoadVersionDataAsync();

// Access version info
string externalVersion = VersionServices.VersionExternal;  // "1.0.0"
string internalVersion = VersionServices.VersionInternal;  // "1.0.0-42.main.abc123"
string branch = VersionServices.Branch;                     // "main"
string commit = VersionServices.Commit;                     // "abc123"
string buildNumber = VersionServices.BuildNumber;           // "42"

// Check if app is outdated
bool outdated = VersionServices.IsOutdatedVersion("1.1.0");

var timeService = new TimeService();

// Get current times
float unityTime = timeService.UnityTime;        // Time.time equivalent
long unixTime = timeService.UnixTime;           // Unix timestamp
DateTime dateTime = timeService.DateTime;       // DateTime.UtcNow

// Conversions
long unix = timeService.DateTimeToUnix(DateTime.UtcNow);
DateTime dt = timeService.UnixToDateTime(unix);

// Define commands
public struct MovePlayerCommand : ICommand
{
    public int PlayerId;
    public Vector3 Direction;
}

var commandService = new CommandService(messageBroker);

// Execute commands
await commandService.ExecuteCommand(new MovePlayerCommand 
{
    PlayerId = 1,
    Direction = Vector3.forward
});

// Fire and forget
commandService.ExecuteCommand(new MovePlayerCommand { PlayerId = 2 });