using System;
using System.IO;
using System.Text;

namespace AcDream.Core.Chat;

/// <summary>
/// Retail's <c>@log</c> chat-to-file capture.
/// </summary>
/// <remarks>
/// <para>
/// This is NOT an automatic session transcript. Retail opens a log only when
/// the player asks for one by name — <c>ClientCommunicationSystem::DoSetOutput
/// @0x0057E4F0</c> takes a filename, <c>StartCopyOutputToFile @0x0057C8A0</c>
/// does the <c>fopen(name, "a+")</c>, and running the command again with no
/// argument closes it. The file is APPENDED to, never rotated and never
/// truncated, which is what retail's own help promises: "If this file already
/// exists, it will add the additional text to the end of it."
/// </para>
/// <para>
/// Every line goes out as <c>timestamp + text + "\n"</c>
/// (<c>fprintf(s_pLogFile, "%ls%ls\n", …) @0x00563E5B</c>, inside
/// <c>ClientSystem::AddTextToScroll</c>), with the timestamp present only when
/// the <c>DisplayTimeStamps</c> option is on — the log and the chat window
/// share the one stamp rather than deciding separately.
/// </para>
/// <para>
/// File handling only. What a line SAYS is composed upstream, because retail
/// logs the finished display line rather than re-deriving one.
/// </para>
/// </remarks>
public sealed class ChatSessionLog : IDisposable
{
    private readonly string _baseDirectory;
    private StreamWriter? _writer;

    /// <param name="baseDirectory">
    /// Where a bare filename lands. Retail says "your Asheron's Call
    /// directory" — its install directory — which acdream cannot use: the
    /// launcher replaces the install atomically on update, so a file written
    /// there is wiped or blocks the update. The client's own log directory is
    /// the equivalent that survives. Rooted paths are still honoured verbatim,
    /// as retail's <c>fopen</c> would.
    /// </param>
    public ChatSessionLog(string baseDirectory)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(baseDirectory);
        _baseDirectory = baseDirectory;
    }

    /// <summary>The name the player asked for, or null when nothing is open.</summary>
    public string? CurrentName { get; private set; }

    public bool IsOpen => _writer is not null;

    /// <summary>
    /// Retail appends <c>.txt</c> to an extensionless name
    /// (<c>PSUtils::get_extension</c> against the empty string, then
    /// <c>+= ".txt"</c>). A name that already carries ANY extension is left
    /// alone — "chat.old" stays "chat.old" rather than becoming "chat.old.txt".
    /// </summary>
    public static string EnsureExtension(string name)
        => Path.GetExtension(name).Length == 0 ? name + ".txt" : name;

    /// <summary>
    /// Opens <paramref name="name"/> for append, closing any log already open
    /// first — retail's <c>StartCopyOutputToFile</c> calls <c>CloseLogFile</c>
    /// before it does anything else.
    /// </summary>
    /// <returns>
    /// Whether the file opened. Retail reports failure to the player rather
    /// than treating it as fatal, so an unwritable path is an ordinary answer
    /// here and not an exception.
    /// </returns>
    public bool Open(string name, out string resolvedName)
    {
        resolvedName = string.Empty;
        Close();

        if (string.IsNullOrWhiteSpace(name))
            return false;

        resolvedName = EnsureExtension(name.Trim());

        try
        {
            string path = Path.IsPathRooted(resolvedName)
                ? resolvedName
                : Path.Combine(_baseDirectory, resolvedName);

            string? directory = Path.GetDirectoryName(path);
            if (!string.IsNullOrEmpty(directory))
                Directory.CreateDirectory(directory);

            _writer = new StreamWriter(
                new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite),
                new UTF8Encoding(encoderShouldEmitUTF8Identifier: false))
            {
                // Flushed per line: a chat log's whole point is being readable
                // while the client is still running, and a crash must not eat
                // the tail that explains it.
                AutoFlush = true,
            };
            CurrentName = resolvedName;
            return true;
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException
            or ArgumentException or NotSupportedException)
        {
            _writer = null;
            CurrentName = null;
            return false;
        }
    }

    /// <summary>Closes the open log, if any.</summary>
    /// <returns>
    /// Whether one WAS open. Retail's <c>CloseLogFile</c> returns this and its
    /// caller uses it to choose between "closed" and "please specify a file".
    /// </returns>
    public bool Close()
    {
        if (_writer is null)
            return false;

        try
        {
            _writer.Dispose();
        }
        catch (IOException)
        {
            // The line is already gone; failing to flush a closing file is not
            // something the player can act on.
        }

        _writer = null;
        CurrentName = null;
        return true;
    }

    /// <summary>
    /// Writes one transcript line. A no-op when no log is open, so the caller
    /// can hand every line over unconditionally the way retail does.
    /// </summary>
    public void Write(string? timestampPrefix, string? text)
    {
        StreamWriter? writer = _writer;
        if (writer is null)
            return;

        try
        {
            writer.Write(timestampPrefix);
            writer.Write(text);
            writer.Write('\n');
        }
        catch (IOException)
        {
            // A vanished drive or a full disk stops the log; it must not stop
            // chat. Retail ignores fprintf's return except to warn about very
            // long lines.
        }
    }

    public void Dispose() => Close();
}

/// <summary>
/// What one <c>@log</c> invocation did, so the caller can print retail's
/// replies without reaching into the file handle.
/// </summary>
/// <param name="Opened">A new log was opened.</param>
/// <param name="Closed">
/// A log that WAS open got closed. True both when closing is the whole point
/// and when opening a second log displaced the first — retail's
/// <c>StartCopyOutputToFile</c> closes before it opens, and announces it.
/// </param>
/// <param name="Name">The resolved name of the new log, extension included.</param>
/// <param name="ClosedName">The name of the log that was closed, if any.</param>
public readonly record struct ChatLogResult(
    bool Opened,
    bool Closed,
    string Name,
    string? ClosedName);