using System;
using System.Net;
using System.Net.Sockets;
using AcDream.Core.Net;

namespace AcDream.App.Net;

/// <summary>
/// Owns the network-side lifecycle of a live <see cref="WorldSession"/> —
/// DNS resolution, endpoint construction, session instantiation, per-frame
/// <c>Tick</c>, and disposal. The post-construction work (event wiring,
/// <c>Connect</c>, character validation, <c>EnterWorld</c>, post-login UI
/// state setup) stays in <c>GameWindow</c> for now because it touches
/// renderer / chat / player-controller state that hasn't been extracted yet.
/// </summary>
/// <remarks>
/// <para>
/// Step 2 of the extraction sequence described in
/// <c>docs/architecture/code-structure.md</c> §4. Future expansions can
/// fold more of <c>TryStartLiveSession</c> into this controller as the
/// surrounding state (event handlers, command bus, settings VM) gets
/// extracted in later steps.
/// </para>
/// <para>
/// <strong>Behavior preservation contract:</strong> this class produces
/// byte-identical console output and event-wireup sequencing to the
/// pre-refactor inline code path. The DNS-resolution lines, the
/// "live: connecting to ..." line, and the wiring-vs-Connect ordering
/// all match the previous flow.
/// </para>
/// </remarks>
public sealed class LiveSessionController : IDisposable
{
    /// <summary>
    /// Active session, or <see langword="null"/> when offline / before
    /// <see cref="CreateAndWire"/> succeeded / after <see cref="Dispose"/>.
    /// </summary>
    public WorldSession? Session { get; private set; }

    /// <summary>
    /// Resolves the endpoint, instantiates the <see cref="WorldSession"/>,
    /// hands it to <paramref name="wireEvents"/> for caller-side event
    /// subscriptions, and returns the live session. The caller is
    /// responsible for the subsequent <c>Connect</c> /
    /// <c>EnterWorld</c> dance.
    /// </summary>
    public WorldSession? CreateAndWire(RuntimeOptions options, Action<WorldSession> wireEvents)
    {
        if (options is null) throw new ArgumentNullException(nameof(options));
        if (wireEvents is null) throw new ArgumentNullException(nameof(wireEvents));

        if (!options.LiveMode) return null;

        if (string.IsNullOrEmpty(options.LiveUser) || string.IsNullOrEmpty(options.LivePass))
        {
            Console.WriteLine("live: ACDREAM_LIVE set but TEST_USER/TEST_PASS missing; skipping");
            return null;
        }

        try
        {
            var endpoint = ResolveEndpoint(options.LiveHost, options.LivePort);
            Console.WriteLine($"live: connecting to {endpoint} as {options.LiveUser}");
            Session = new WorldSession(endpoint);
            wireEvents(Session);
            return Session;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"live: session setup failed: {ex.Message}");
            Session?.Dispose();
            Session = null;
            return null;
        }
    }

    /// <summary>
    /// Drains the inbound network queue. Proxies to
    /// <see cref="WorldSession.Tick"/>; no-op when <see cref="Session"/>
    /// is <see langword="null"/>.
    /// </summary>
    public void Tick() => Session?.Tick();

    /// <summary>
    /// Tears down the live session. Safe to call multiple times.
    /// </summary>
    public void Dispose()
    {
        Session?.Dispose();
        Session = null;
    }

    /// <summary>
    /// Resolve a host string (literal IP or DNS name) to an
    /// <see cref="IPEndPoint"/>. Pre-refactor logic preserved exactly:
    /// try <see cref="IPAddress.TryParse"/> first, fall back to
    /// <see cref="Dns.GetHostAddresses"/>, prefer IPv4 (ACE + retail use
    /// IPv4 UDP exclusively), throw on empty resolution.
    /// </summary>
    private static IPEndPoint ResolveEndpoint(string host, int port)
    {
        IPAddress ip;
        if (!IPAddress.TryParse(host, out ip!))
        {
            var addrs = Dns.GetHostAddresses(host);
            ip = Array.Find(addrs, a => a.AddressFamily == AddressFamily.InterNetwork)
                ?? (addrs.Length > 0
                    ? addrs[0]
                    : throw new Exception($"DNS resolved no addresses for '{host}'"));
            Console.WriteLine($"live: resolved {host} → {ip}");
        }
        return new IPEndPoint(ip, port);
    }
}