module mysql.protocol.packets;

import std.algorithm;
import std.conv;
import std.datetime;
import std.digest.sha;
import std.exception;
import std.range;
import std.socket;
import std.stdio;
import std.string;
import std.traits;
import std.variant;

import mysql.common;
import mysql.protocol.constants;
import mysql.protocol.extra_types;
public import mysql.protocol.packet_helpers;

/**
 * The server sent back a MySQL error code and message. If the server is 4.1+,
 * there should also be an ANSI/ODBC-standard SQLSTATE error code.
 *
 * See_Also: https://dev.mysql.com/doc/refman/5.5/en/error-messages-server.html
 */
class MySQLReceivedException: MySQLException
{
    ushort errorCode;
    char[5] sqlState;

    this(OKErrorPacket okp, string file, size_t line) pure
    {
        this(okp.message, okp.serverStatus, okp.sqlState, file, line);
    }

    this(string msg, ushort errorCode, char[5] sqlState, string file, size_t line) pure
    {
        this.errorCode = errorCode;
        this.sqlState = sqlState;
        super("MySQL error: " ~ msg, file, line);
    }
}
alias MySQLReceivedException MYXReceived;

void enforcePacketOK(string file = __FILE__, size_t line = __LINE__)(OKErrorPacket okp)
{
    enforce(!okp.error, new MYXReceived(okp, file, line));
}

/**
 * A struct representing an OK or Error packet
 * See_Also: http://forge.mysql.com/wiki/MySQL_Internals_ClientServer_Protocol#Types_Of_Result_Packets
 * OK packets begin with a zero byte - Error packets with 0xff
 */
struct OKErrorPacket
{
    bool     error;
    ulong    affected;
    ulong    insertID;
    ushort   serverStatus;
    ushort   warnings;
    char[5]  sqlState;
    string   message;

    this(ubyte[] packet)
    {
        if (packet.front == ResultPacketMarker.error)
        {
            packet.popFront(); // skip marker/field code
            error = true;

            enforceEx!MYXProtocol(packet.length > 2, "Malformed Error packet - Missing error code");
            serverStatus = packet.consume!short(); // error code into server state
            if (packet.front == cast(ubyte) '#') //4.1+ error packet
            {
                packet.popFront(); // skip 4.1 marker
                enforceEx!MYXProtocol(packet.length > 5, "Malformed Error packet - Missing SQL state");
                sqlState[] = (cast(char[])packet[0 .. 5])[];
                packet = packet[5..$];
            }
        }
        else if(packet.front == ResultPacketMarker.ok)
        {
            packet.popFront(); // skip marker/field code

            enforceEx!MYXProtocol(packet.length > 1, "Malformed OK packet - Missing affected rows");
            auto lcb = packet.consumeIfComplete!LCB();
            assert(!lcb.isNull);
            assert(!lcb.isIncomplete);
            affected = lcb.value;

            enforceEx!MYXProtocol(packet.length > 1, "Malformed OK packet - Missing insert id");
            lcb = packet.consumeIfComplete!LCB();
            assert(!lcb.isNull);
            assert(!lcb.isIncomplete);
            insertID = lcb.value;

            enforceEx!MYXProtocol(packet.length > 2,
                    format("Malformed OK packet - Missing server status. Expected length > 2, got %d", packet.length));
            serverStatus = packet.consume!short();

            enforceEx!MYXProtocol(packet.length >= 2, "Malformed OK packet - Missing warnings");
            warnings = packet.consume!short();
        }
        else
            throw new MYXProtocol("Malformed OK/Error packet - Incorrect type of packet", __FILE__, __LINE__);

        // both OK and Error packets end with a message for the rest of the packet
        message = cast(string)packet.idup;
    }
}

/**
 * A struct representing a field (column) description packet
 *
 * These packets, one for each column are sent before the data of a result set,
 * followed by an EOF packet.
 *
 * See_Also: http://forge.mysql.com/wiki/MySQL_Internals_ClientServer_Protocol#Field_Packet
 */
struct FieldDescription
{
private:
    string   _db;
    string   _table;
    string   _originalTable;
    string   _name;
    string   _originalName;
    ushort   _charSet;
    uint     _length;
    SQLType  _type;
    FieldFlags _flags;
    ubyte    _scale;
    ulong    _deflt;
    uint     chunkSize;
    void delegate(ubyte[], bool) chunkDelegate;

public:
    /**
     * Construct a FieldDescription from the raw data packet
     *
     * Parameters: packet = The packet contents excluding the 4 byte packet header
     */
    this(ubyte[] packet)
    in
    {
        assert(packet.length);
    }
    out
    {
        assert(!packet.length, "not all bytes read during FieldDescription construction");
    }
    body
    {
        packet.skip(4); // Skip catalog - it's always 'def'
        _db             = packet.consume!LCS();
        _table          = packet.consume!LCS();
        _originalTable  = packet.consume!LCS();
        _name           = packet.consume!LCS();
        _originalName   = packet.consume!LCS();

        enforceEx!MYXProtocol(packet.length >= 13, "Malformed field specification packet");
        packet.popFront(); // one byte filler here
        _charSet    = packet.consume!short();
        _length     = packet.consume!int();
        _type       = cast(SQLType)packet.consume!ubyte();
        _flags      = cast(FieldFlags)packet.consume!short();
        _scale      = packet.consume!ubyte();
        packet.skip(2); // two byte filler

        if(packet.length)
        {
            packet.skip(1); // one byte filler
            auto lcb = packet.consumeIfComplete!LCB();
            assert(!lcb.isNull);
            assert(!lcb.isIncomplete);
            _deflt = lcb.value;
        }
    }

    /// Database name for column as string
    @property string db() pure const nothrow { return _db; }

    /// Table name for column as string - this could be an alias as in 'from tablename as foo'
    @property string table() pure const nothrow { return _table; }

    /// Real table name for column as string
    @property string originalTable() pure const nothrow { return _originalTable; }

    /// Column name as string - this could be an alias
    @property string name() pure const nothrow { return _name; }

    /// Real column name as string
    @property string originalName() pure const nothrow { return _originalName; }

    /// The character set in force
    @property ushort charSet() pure const nothrow { return _charSet; }

    /// The 'length' of the column as defined at table creation
    @property uint length() pure const nothrow { return _length; }

    /// The type of the column hopefully (but not always) corresponding to enum SQLType.
    /// Only the low byte currently used.
    @property SQLType type() pure const nothrow { return _type; }

    /// Column flags - unsigned, binary, null and so on
    @property FieldFlags flags() pure const nothrow { return _flags; }

    /// Precision for floating point values
    @property ubyte scale() pure const nothrow { return _scale; }

    /// NotNull from flags
    @property bool notNull() pure const nothrow { return (_flags & FieldFlags.NOT_NULL) != 0; }

    /// Unsigned from flags
    @property bool unsigned() pure const nothrow { return (_flags & FieldFlags.UNSIGNED) != 0; }

    /// Binary from flags
    @property bool binary() pure const nothrow { return (_flags & FieldFlags.BINARY) != 0; }

    /// Is-enum from flags
    @property bool isenum() pure const nothrow { return (_flags & FieldFlags.ENUM) != 0; }

    /// Is-set (a SET column that is) from flags
    @property bool isset() pure const nothrow { return (_flags & FieldFlags.SET) != 0; }

    void show() const
    {
        writefln("%s %d %x %016b", _name, _length, _type, _flags);
    }
}

/**
 * A struct representing a prepared statement parameter description packet
 *
 * These packets, one for each parameter are sent in response to the prepare
 * command, followed by an EOF packet.
 *
 * Sadly it seems that this facility is only a stub. The correct number of
 * packets is sent, but they contain no useful information and are all the same.
 */
struct ParamDescription
{
private:
    ushort _type;
    FieldFlags _flags;
    ubyte _scale;
    uint _length;

public:
    this(ubyte[] packet)
    {
        _type   = packet.consume!short();
        _flags  = cast(FieldFlags)packet.consume!short();
        _scale  = packet.consume!ubyte();
        _length = packet.consume!int();
        assert(!packet.length);
    }
    @property uint length() pure const nothrow { return _length; }
    @property ushort type() pure const nothrow { return _type; }
    @property FieldFlags flags() pure const nothrow { return _flags; }
    @property ubyte scale() pure const nothrow { return _scale; }
    @property bool notNull() pure const nothrow { return (_flags & FieldFlags.NOT_NULL) != 0; }
    @property bool unsigned() pure const nothrow { return (_flags & FieldFlags.UNSIGNED) != 0; }
}

bool isEOFPacket(in ubyte[] packet) pure nothrow
in
{
    assert(!packet.empty);
}
body
{
    return packet.front == ResultPacketMarker.eof && packet.length < 9;
}

/**
 * A struct representing an EOF packet from the server
 *
 * An EOF packet is sent from the server after each sequence of field
 * description and parameter description packets, and after a sequence of
 * result set row packets.
 * An EOF packet is also called "Last Data Packet" or "End Packet".
 *
 * These EOF packets contain a server status and a warning count.
 *
 * See_Also: http://forge.mysql.com/wiki/MySQL_Internals_ClientServer_Protocol#EOF_Packet
 */
struct EOFPacket
{
private:
    ushort _warnings;
    ushort _serverStatus;

public:

   /**
    * Construct an EOFPacket struct from the raw data packet
    *
    * Parameters: packet = The packet contents excluding the 4 byte packet header
    */
    this(ubyte[] packet)
    in
    {
        assert(packet.isEOFPacket());
        assert(packet.length == 5);
    }
    out
    {
        assert(!packet.length);
    }
    body
    {
        packet.popFront(); // eof marker
        _warnings = packet.consume!short();
        _serverStatus = packet.consume!short();
    }

    /// Retrieve the warning count
    @property ushort warnings() pure const nothrow { return _warnings; }

    /// Retrieve the server status
    @property ushort serverStatus() pure const nothrow { return _serverStatus; }
}


/**
 * A struct representing the collation of a sequence of FieldDescription packets.
 *
 * This data gets filled in after a query (prepared or otherwise) that creates
 * a result set completes. All the FD packets, and an EOF packet must be eaten
 * before the row data packets can be read.
 */
struct ResultSetHeaders
{
	import mysql.connection;

private:
    FieldDescription[] _fieldDescriptions;
    string[] _fieldNames;
    ushort _warnings;

public:

    /**
     * Construct a ResultSetHeaders struct from a sequence of FieldDescription
     * packets and an EOF packet.
     *
     * Parameters:
     *    con = A Connection via which the packets are read
     *    fieldCount = the number of fields/columns generated by the query
     */
    this(Connection con, uint fieldCount)
    {
        scope(failure) con.kill();

        _fieldNames.length = _fieldDescriptions.length = fieldCount;
        foreach (size_t i; 0 .. fieldCount)
        {
            auto packet = con.getPacket();
            enforceEx!MYXProtocol(!packet.isEOFPacket(),
                    "Expected field description packet, got EOF packet in result header sequence");

            _fieldDescriptions[i]   = FieldDescription(packet);
            _fieldNames[i]          = _fieldDescriptions[i]._name;
        }
        auto packet = con.getPacket();
        enforceEx!MYXProtocol(packet.isEOFPacket(),
                "Expected EOF packet in result header sequence");
        auto eof = EOFPacket(packet);
        con._serverStatus = eof._serverStatus;
        _warnings = eof._warnings;
    }

    /**
     * Add specialization information to one or more field descriptions.
     *
     * Currently the only specialization supported is the capability to deal with long data
     * e.g. BLOB or TEXT data in chunks by stipulating a chunkSize and a delegate to sink
     * the data.
     *
     * Parameters:
     *    csa = An array of ColumnSpecialization structs
     */
    void addSpecializations(ColumnSpecialization[] csa)
    {
        foreach(CSN csn; csa)
        {
            enforceEx!MYX(csn.cIndex < fieldCount && _fieldDescriptions[csn.cIndex].type == csn.type,
                    "Column specialization index or type does not match the corresponding column.");
            _fieldDescriptions[csn.cIndex].chunkSize = csn.chunkSize;
            _fieldDescriptions[csn.cIndex].chunkDelegate = csn.chunkDelegate;
        }
    }

    /// Index into the set of field descriptions
    FieldDescription opIndex(size_t i) pure nothrow { return _fieldDescriptions[i]; }
    /// Get the number of fields in a result row.
    @property size_t fieldCount() pure const nothrow { return _fieldDescriptions.length; }
    /// Get the warning count as per the EOF packet
    @property ushort warnings() pure const nothrow { return _warnings; }
    /// Get an array of strings representing the column names
    @property string[] fieldNames() pure nothrow { return _fieldNames; }
    /// Get an array of the field descriptions
    @property FieldDescription[] fieldDescriptions() pure nothrow { return _fieldDescriptions; }

    void show() const
    {
        foreach (FieldDescription fd; _fieldDescriptions)
            fd.show();
    }
}

/**
 * A struct representing the collation of a prepared statement parameter description sequence
 *
 * As noted above - parameter descriptions are not fully implemented by MySQL.
 */
struct PreparedStmtHeaders
{
	import mysql.connection;
	
package:
    Connection _con;
    ushort _colCount, _paramCount;
    FieldDescription[] _colDescriptions;
    ParamDescription[] _paramDescriptions;
    ushort _warnings;

    bool getEOFPacket()
    {
        auto packet = _con.getPacket();
        if (!packet.isEOFPacket())
            return false;
        EOFPacket eof = EOFPacket(packet);
        _con._serverStatus = eof._serverStatus;
        _warnings += eof._warnings;
        return true;
    }

public:
    this(Connection con, ushort cols, ushort params)
    {
        scope(failure) con.kill();

        _con = con;
        _colCount = cols;
        _paramCount = params;
        _colDescriptions.length = cols;
        _paramDescriptions.length = params;

        // The order in which fields are sent is params first, followed by EOF,
        // then cols followed by EOF The parameter specs are useless - they are
        // all the same. This observation is coroborated by the fact that the
        // C API does not have any information about parameter types either.
        // WireShark gives up on these records also.
        foreach (size_t i; 0.._paramCount)
            _con.getPacket();  // just eat them - they are not useful

        if (_paramCount)
            enforceEx!MYXProtocol(getEOFPacket(), "Expected EOF packet in result header sequence");

        foreach(size_t i; 0.._colCount)
           _colDescriptions[i] = FieldDescription(_con.getPacket());

        if (_colCount)
            enforceEx!MYXProtocol(getEOFPacket(), "Expected EOF packet in result header sequence");
    }

    ParamDescription param(size_t i) pure const nothrow { return _paramDescriptions[i]; }
    FieldDescription col(size_t i) pure const nothrow { return _colDescriptions[i]; }

    @property ParamDescription[] paramDescriptions() pure nothrow { return _paramDescriptions; }
    @property FieldDescription[] fieldDescriptions() pure nothrow { return _colDescriptions; }

    @property paramCount() pure const nothrow { return _paramCount; }
    @property ushort warnings() pure const nothrow { return _warnings; }

    void showCols() const
    {
        writefln("%d columns", _colCount);
        foreach (FieldDescription fd; _colDescriptions)
        {
            writefln("%10s %10s %10s %10s %10s %d %d %02x %016b %d",
                    fd._db, fd._table, fd._originalTable, fd._name, fd._originalName,
                    fd._charSet, fd._length, fd._type, fd._flags, fd._scale);
        }
    }
}