package main

import (
    "time"
)

const MAX_PAYLOAD_SIZE = 100 * 1024

// replacement for time.Time when gobbing
type MsgTime struct {
    Sec  int64
    Nsec int32
}

type MsgHeader struct {
    Ts  MsgTime
    Typ uint16
}

const VERSION = 1

const (
    MSG_TYPE_NOP = iota
    MSG_TYPE_HELLO
    MSG_TYPE_HELLO_RESP
    MSG_TYPE_HTTP
    MSG_TYPE_MYSQL // Now deprecated
    MSG_TYPE_REPORT
    MSG_TYPE_REDIS
    MSG_TYPE_MYSQL_TRANSACTION
    MSG_TYPE_HTTP_TRANSACTION
    MSG_TYPE_REDIS_TRANSACTION
)

type IpPortTuple struct {
    Src_ip, Dst_ip     uint32
    Src_port, Dst_port uint16
}

type CmdlineTuple struct {
    Src, Dst []byte
}

type HelloMessage struct {
    Version uint16
    Flags   uint16
    Authstr []byte // must be 40 bytes
    Name    []byte
}

// Agent connection flags
const (
    AGENT_USE_TLS = 1 << iota
)

type HelloRespMessage struct {
    Flags         uint16
    Response_code uint8
    Msg           []byte
}

const HTTP_VERSION = 1

const (
    HTTP_FLAGS_DIR_INITIAL = 1 << iota
    HTTP_FLAGS_IS_REQUEST
)

const MYSQL_VERSION = 1

const (
    MYSQL_FLAGS_DIR_INITIAL = 1 << iota
    MYSQL_FLAGS_IS_REQUEST
    MYSQL_FLAGS_IS_TRUNCATED
)

const REDIS_VERSION = 1

const (
    REDIS_FLAGS_DIR_INITIAL = 1 << iota
    REDIS_FLAGS_IS_REQUEST
)

type PublishMessage struct {
    Version      uint16
    Stream_id    uint32
    Tuple        *IpPortTuple
    CmdlineTuple *CmdlineTuple
    Flags        uint16
    Data         []byte
    Raw          []byte
}

type PublishTransaction struct {
    Data []byte
}

type ReportMessage struct {
    Msg []byte
}

func NewMsgTime(ts time.Time) MsgTime {
    return MsgTime{
        Sec:  ts.Unix(),
        Nsec: int32(ts.Nanosecond()),
    }
}

func (msgtime *MsgTime) Time() time.Time {
    return time.Unix(msgtime.Sec, int64(msgtime.Nsec)).UTC()
}

func read_lstring(data []byte, offset int) ([]byte, int) {
    length, off := read_linteger(data, offset)
    return data[off : off+int(length)], off + int(length)
}
func read_linteger(data []byte, offset int) (uint64, int) {
    switch uint8(data[offset]) {
    case 0xfe:
        return uint64(data[offset+1]) | uint64(data[offset+2])<<8 |
                uint64(data[offset+2])<<16 | uint64(data[offset+3])<<24 |
                uint64(data[offset+4])<<32 | uint64(data[offset+5])<<40 |
                uint64(data[offset+6])<<48 | uint64(data[offset+7])<<56,
            offset + 9
    case 0xfd:
        return uint64(data[offset+1]) | uint64(data[offset+2])<<8 |
            uint64(data[offset+2])<<16, offset + 4
    case 0xfc:
        return uint64(data[offset+1]) | uint64(data[offset+2])<<8, offset + 3
    }

    if uint64(data[offset]) >= 0xfb {
        panic("Unexpected value in read_linteger")
    }

    return uint64(data[offset]), offset + 1
}

func read_length(data []byte, offset int) int {
    length := uint32(data[offset]) |
        uint32(data[offset+1])<<8 |
        uint32(data[offset+2])<<16
    return int(length)
}