package telnet

// import "bytes"
import "io"
import "strings"
import "fmt"
import "compress/zlib"
import "gitlab.com/beoran/woe/monolog"

// This Telnet module implements a subset of the Telnet protocol.

// Telnet states
type TelnetState int

const (
	data_state        TelnetState = iota
	iac_state                     = iota
	will_state                    = iota
	wont_state                    = iota
	do_state                      = iota
	dont_state                    = iota
	sb_state                      = iota
	sb_data_state                 = iota
	sb_data_iac_state             = iota
)

// Telnet event type constants
type EventType int

const (
	TELNET_DATA_EVENT         EventType = iota
	TELNET_NAWS_EVENT         EventType = iota
	TELNET_TTYPE_EVENT        EventType = iota
	TELNET_SUBNEGOTIATE_EVENT EventType = iota
	TELNET_IAC_EVENT          EventType = iota
	TELNET_COMPRESS_EVENT     EventType = iota
	TELNET_ENVIRONMENT_EVENT  EventType = iota
	TELNET_MSSP_EVENT         EventType = iota
	TELNET_ZMP_EVENT          EventType = iota
	TELNET_WILL_EVENT         EventType = iota
	TELNET_WONT_EVENT         EventType = iota
	TELNET_DO_EVENT           EventType = iota
	TELNET_DONT_EVENT         EventType = iota
	TELNET_ERROR_EVENT        EventType = iota
	TELNET_UNKNOWN_EVENT      EventType = iota
	TELNET_NIL_EVENT          EventType = iota
)

// Telnet event types

type Event interface {
	Type() EventType
}

type DataEvent struct {
	Data []byte
}

func (me DataEvent) Type() EventType { return TELNET_DATA_EVENT }

type NAWSEvent struct {
	W int
	H int
}

func (me NAWSEvent) Type() EventType { return TELNET_NAWS_EVENT }

type TTypeEvent struct {
	Telopt byte
	Name   string
}

func (me TTypeEvent) Type() EventType { return TELNET_TTYPE_EVENT }

type SubnegotiateEvent struct {
	Telopt byte
	Buffer []byte
}

func (me SubnegotiateEvent) Type() EventType { return TELNET_SUBNEGOTIATE_EVENT }

type IACEvent struct {
	Telopt byte
}

func (me IACEvent) Type() EventType { return TELNET_IAC_EVENT }

type CompressEvent struct {
	Compress bool
}

func (me CompressEvent) Type() EventType { return TELNET_COMPRESS_EVENT }

// Storage for environment values
type Environment struct {
	Type  byte
	Value string
}

type EnvironmentEvent struct {
	Telopt byte
	Vars   []Environment
}

func (me EnvironmentEvent) Type() EventType { return TELNET_ENVIRONMENT_EVENT }

type MSSPEvent struct {
	Telopt byte
	Vars   map[string]string
}

func (me MSSPEvent) Type() EventType { return TELNET_MSSP_EVENT }

type ZMPEvent struct {
	Vars []string
}

func (me ZMPEvent) Type() EventType { return TELNET_ZMP_EVENT }

type WillEvent struct {
	Telopt byte
}

func (me WillEvent) Type() EventType { return TELNET_WILL_EVENT }

type WontEvent struct {
	Telopt byte
}

func (me WontEvent) Type() EventType { return TELNET_WONT_EVENT }

type DoEvent struct {
	Telopt byte
}

func (me DoEvent) Type() EventType { return TELNET_DO_EVENT }

type DontEvent struct {
	Telopt byte
}

func (me DontEvent) Type() EventType { return TELNET_DONT_EVENT }

// For protocol errors.
type ErrorEvent struct {
	error string
}

func (me ErrorEvent) Type() EventType { return TELNET_ERROR_EVENT }

// Returns the numerical event type of an event. Useful for direct comparison.
func EventTypeOf(event Event) EventType {
	if event == nil {
		return TELNET_NIL_EVENT
	}
	return event.Type()
}

// Returns true if the event is of the given type, or false if not
func IsEventType(event Event, typ EventType) bool {
	return EventTypeOf(event) == typ
}

type EventChannel chan (Event)

type Telopt struct {
	telopt byte
	us     byte
	him    byte
}

type Telnet struct {
	Events    EventChannel
	ToClient  chan ([]byte)
	telopts   map[byte]Telopt
	state     TelnetState
	compress  bool
	zwriter   zlib.Writer
	zreader   io.ReadCloser
	buffer    []byte
	sb_telopt byte
}

func New() (telnet *Telnet) {
	events := make(EventChannel, 64)
	toclient := make(chan ([]byte), 64)
	telopts := make(map[byte]Telopt)
	state := data_state
	compress := false
	var zwriter zlib.Writer
	var zreader io.ReadCloser
	var buffer []byte = nil
	sb_telopt := byte(0)
	telnet = &Telnet{events, toclient, telopts, state, compress, zwriter, zreader, buffer, sb_telopt}
	return telnet
}

// Starts compresssion
func (me *Telnet) StartCompression() {
	// XXX implement compression.
	// var zwbuf  bytes.Buffer
	// me.zwriter = zlib.NewWriter(&zwbuf);
}

// Closes the telnet connection, send last compressed data if needed.
func (me *Telnet) Close() {
	if me.compress {
		me.zwriter.Close()
		me.zreader.Close()
	}
}

// Filters raw text, only compressing it if needed.
func (me *Telnet) SendRaw(in []byte) {
	// XXX Handle compression here later
	me.ToClient <- in
}

// Filters text, escaping IAC bytes.
func (me *Telnet) SendEscaped(in []byte) {
	buffer := make([]byte, len(in)*2, len(in)*2)
	outdex := 0
	/* Double IAC characters to escape them. */
	for index := 0; index < len(in); index++ {
		now := in[index]
		if now == TELNET_IAC {
			buffer[outdex] = TELNET_IAC
			outdex++
		}
		buffer[outdex] = now
		outdex++
	}
	me.SendRaw(buffer)
}

// Send negotiation bytes
func (me *Telnet) SendNegotiate(cmd byte, telopt byte) {
	buffer := make([]byte, 3)
	buffer[0] = TELNET_IAC
	buffer[1] = cmd
	buffer[2] = telopt
	me.SendRaw(buffer)
}

func (me *Telnet) SendEvent(event Event) {
	me.Events <- event
}

// Parse a subnegotiation buffer for a naws event
func (me *Telnet) SubnegotiateNAWS(buffer []byte) {
	// Some clients, like Gnome-Mud can't even get this right. Grrr!
	if buffer == nil || len(buffer) != 4 {
		monolog.Warning("Bad NAWS negotiation: #{buffer}")
		return
	}
	var w int = (int(buffer[0]) << 8) + int(buffer[1])
	var h int = (int(buffer[2]) << 8) + int(buffer[3])
	me.SendEvent(&NAWSEvent{w, h})
}

// process an ENVIRON/NEW-ENVIRON subnegotiation buffer
func (me *Telnet) SubnegotiateEnviron(buffer []byte) {
	var vars []Environment
	var cmd []byte
	fb := buffer[0]
	// First byte must be a valid command
	if fb != TELNET_ENVIRON_SEND && fb != TELNET_ENVIRON_IS && fb != TELNET_ENVIRON_INFO {
		monolog.Warning("telopt environment subneg command not valid")
	}

	cmd = append(cmd, fb)

	if len(buffer) == 1 {
		me.SendEvent(&EnvironmentEvent{fb, vars})
		return
	}

	// Second byte must be VAR or USERVAR, if present
	sb := buffer[1]
	if sb != TELNET_ENVIRON_VAR && fb != TELNET_ENVIRON_USERVAR {
		monolog.Warning("telopt environment subneg missing variable type")
		return
	}

	// ensure last byte is not an escape byte (makes parsing later easier)
	lb := buffer[len(buffer)-1]
	if lb == TELNET_ENVIRON_ESC {
		monolog.Warning("telopt environment subneg ends with ESC")
		return
	}

	/* XXX : not implemented yet
	   var variable * Environment = nil
	   index           := 1
	   escape          := false

	   for index := 1 ; index < len(buffer) ; index++ {
	     c := buffer[index]
	     switch c {
	       case TELNET_ENVIRON_VAR:
	           fallthrough
	       case TELNET_ENVIRON_VALUE:
	           fallthrough
	       case TELNET_ENVIRON_USERVAR:
	           if escape {
	               escape = false
	               variable.Value  = append(variable.Value, c)
	           } else if (variable != nil) {
	               vars            = append(vars, variable)
	               variable        = new(Environment)
	               variable.Type   = c
	           } else {
	               variable        = new(Environment)
	               variable.Type   = c
	           }
	     case TELNET_ENVIRON_ESC:
	       escape = true
	     default:
	       variable.Value = append(variable.Value, c)
	     }
	   }
	   // Finally send event
	   me.SendEvent(&EnvironmentEvent{fb, vars})
	*/
}

const (
	MSTATE_NONE = 0
	MSTATE_VAR  = 1
	MSTATE_VAL  = 2
)

// process an MSSP subnegotiation buffer
func (me *Telnet) SubnegotiateMSSP(buffer []byte) {
	if len(buffer) < 1 {
		return
	}

	fb := buffer[0]
	// first byte must be a valid command
	if fb != TELNET_MSSP_VAR {
		monolog.Warning("telopt MSSP subneg data not valid")
		return
	}

	variables := make(map[string]string)
	var variable []byte
	var value []byte
	mstate := MSTATE_NONE

	for index := 0; index < len(buffer); index++ {
		c := buffer[index]

		switch c {
		case TELNET_MSSP_VAR:
			mstate = MSTATE_VAR
			if mstate == MSTATE_VAR {
				variables[string(variable)] = string(value)
				variable = nil
				value = nil
			}
		case TELNET_MSSP_VAL:
			mstate = MSTATE_VAL
		default:
			if mstate == MSTATE_VAL {
				variable = append(variable, c)
			} else {
				value = append(value, c)
			}
		}
	}
	me.SendEvent(&MSSPEvent{fb, variables})
}

// Parse ZMP command subnegotiation buffers
func (me *Telnet) SubnegotiateZMP(buffer []byte) {
	var vars []string
	var variable []byte
	var b byte
	for index := 0; index < len(buffer); index++ {
		b = buffer[index]
		if b == 0 {
			vars = append(vars, string(variable))
			variable = nil
		} else {
			variable = append(variable, b)
		}
	}
	me.SendEvent(&ZMPEvent{vars})
}

// parse TERMINAL-TYPE command subnegotiation buffers
func (me *Telnet) SubnegotiateTType(buffer []byte) {
	// make sure request is not empty
	if len(buffer) == 0 {
		monolog.Warning("Incomplete TERMINAL-TYPE request")
		return
	}

	fb := buffer[0]
	if fb != TELNET_TTYPE_IS && fb != TELNET_TTYPE_SEND {
		monolog.Warning("TERMINAL-TYPE request has invalid type %d (%v)", fb, buffer)
		return
	}

	term := string(buffer[1:])
	me.SendEvent(&TTypeEvent{fb, term})
}

// process a subnegotiation buffer; returns true if the current buffer
// must be aborted and reprocessed due to COMPRESS2 being activated
func (me *Telnet) DoSubnegotiate(buffer []byte) bool {
	switch me.sb_telopt {
	case TELNET_TELOPT_COMPRESS2:
		// received COMPRESS2 begin marker, setup our zlib box and
		// start handling the compressed stream if it's not already.
		me.compress = true
		me.SendEvent(&CompressEvent{me.compress})
		return true
	// specially handled subnegotiation telopt types
	case TELNET_TELOPT_TTYPE:
		me.SubnegotiateTType(buffer)
	case TELNET_TELOPT_ENVIRON:
		me.SubnegotiateEnviron(buffer)
	case TELNET_TELOPT_NEW_ENVIRON:
		me.SubnegotiateEnviron(buffer)
	case TELNET_TELOPT_MSSP:
		me.SubnegotiateMSSP(buffer)
	case TELNET_TELOPT_NAWS:
		me.SubnegotiateNAWS(buffer)
	case TELNET_TELOPT_ZMP:
		me.SubnegotiateZMP(buffer)
	default:
		// Send catch all subnegotiation event
		me.SendEvent(&SubnegotiateEvent{me.sb_telopt, buffer})
	}
	return false
}

func (me *Telnet) DoNegotiate(state TelnetState, telopt byte) bool {
	switch me.state {
	case will_state:
		me.SendEvent(&WillEvent{telopt})
	case wont_state:
		me.SendEvent(&WontEvent{telopt})
	case do_state:
		me.SendEvent(&DoEvent{telopt})
	case dont_state:
		me.SendEvent(&DontEvent{telopt})
	default:
		monolog.Warning("State not vvalid in  telnet negotiation.")
	}
	me.state = data_state
	return false
}

// Send the current buffer as a DataEvent if it's not empty
// Also empties the buffer if it wasn't emmpty
func (me *Telnet) maybeSendDataEventAndEmptyBuffer() {
	if (me.buffer != nil) && (len(me.buffer) > 0) {
		me.SendEvent(&DataEvent{me.buffer})
		me.buffer = nil
	}
}

// Append a byte to the data buffer
func (me *Telnet) appendByte(bin byte) {
	monolog.Log("TELNET", "Appending to telnet buffer: %d %d", len(me.buffer), cap(me.buffer))
	me.buffer = append(me.buffer, bin)
}

// Process a byte in the data state
func (me *Telnet) dataStateProcessByte(bin byte) bool {
	if bin == TELNET_IAC {
		// receive buffered bytes as data and go to IAC state if it's notempty
		me.maybeSendDataEventAndEmptyBuffer()
		me.state = iac_state
	} else {
		me.appendByte(bin)
	}
	return false
}

// Process a byte in the IAC state
func (me *Telnet) iacStateProcessByte(bin byte) bool {
	switch bin {
	// subnegotiation
	case TELNET_SB:
		me.state = sb_state
	// negotiation commands
	case TELNET_WILL:
		me.state = will_state
	case TELNET_WONT:
		me.state = wont_state
	case TELNET_DO:
		me.state = do_state
	case TELNET_DONT:
		me.state = dont_state
	// IAC escaping
	case TELNET_IAC:
		me.appendByte(TELNET_IAC)
		me.maybeSendDataEventAndEmptyBuffer()
		me.state = data_state
	// some other command
	default:
		me.SendEvent(IACEvent{bin})
		me.state = data_state
	}
	return false
}

// Process a byte in the subnegotiation data state
func (me *Telnet) sbdataStateProcessByte(bin byte) bool {
	// IAC command in subnegotiation -- either IAC SE or IAC IAC
	if bin == TELNET_IAC {
		me.state = sb_data_iac_state
	} else if me.sb_telopt == TELNET_TELOPT_COMPRESS && bin == TELNET_WILL {
		// MCCPv1 defined an invalid subnegotiation sequence (IAC SB 85 WILL SE)
		// to start compression. Catch and discard this case, only support
		// MMCPv2.
		me.state = data_state
	} else {
		me.appendByte(bin)
	}
	return false
}

// Process a byte in the IAC received when processing subnegotiation data state
func (me *Telnet) sbdataiacStateProcessByte(bin byte) bool {
	switch bin {
	//end subnegotiation
	case TELNET_SE:
		me.state = data_state
		// process subnegotiation
		compress := me.DoSubnegotiate(me.buffer)
		// if compression was negotiated, the rest of the stream is compressed
		// and processing it requires decompressing it. Return true to signal
		// this.
		me.buffer = nil
		if compress {
			return true
		}

	// escaped IAC byte
	case TELNET_IAC:
		// push IAC into buffer
		me.appendByte(bin)
		me.state = sb_data_state
	// something else -- protocol error.  attempt to process
	// content in subnegotiation buffer, then evaluate the
	// given command as an IAC code.
	default:
		monolog.Warning("Unexpected byte after IAC inside SB: %d", bin)
		me.state = iac_state
		// subnegotiate with the buffer anyway, even though it's an error
		compress := me.DoSubnegotiate(me.buffer)
		// if compression was negotiated, the rest of the stream is compressed
		// and processing it requires decompressing it. Return true to signal
		// this.
		me.buffer = nil
		if compress {
			return true
		}
	}
	return false
}

// Process a single byte received from the client
func (me *Telnet) ProcessByte(bin byte) bool {
	monolog.Log("TELNET", "ProcessByte %d %d", bin, me.state)
	switch me.state {
	// regular data
	case data_state:
		return me.dataStateProcessByte(bin)
		// IAC received before
	case iac_state:
		return me.iacStateProcessByte(bin)
	case will_state, wont_state, do_state, dont_state:
		return me.DoNegotiate(me.state, bin)
	// subnegotiation started, determine option to subnegotiate
	case sb_state:
		me.sb_telopt = bin
		me.state = sb_data_state
	// subnegotiation data, buffer bytes until the end request
	case sb_data_state:
		return me.sbdataStateProcessByte(bin)
	// IAC received inside a subnegotiation
	case sb_data_iac_state:
		return me.sbdataiacStateProcessByte(bin)
	default:
		//  programing error, shouldn't happen
		panic("Error in telnet state machine!")
	}
	// return false to signal compression needn't start
	return false
}

// Process multiple bytes received from the client
func (me *Telnet) ProcessBytes(bytes []byte) {
	for index := 0; index < len(bytes); {
		bin := bytes[index]
		compress := me.ProcessByte(bin)
		if compress {
			// paper over this for a while...
			// new_bytes = Zlib.inflate(arr.pack('c*')) rescue nil
			// if new_bytes
			//arr = new_bytes.bytes.to_a
		}
		index++
	}
	me.maybeSendDataEventAndEmptyBuffer()
}

// Call this when the server receives data from the client
func (me *Telnet) TelnetReceive(data []byte) {
	// the COMPRESS2 protocol seems to be half-duplex in that only
	// the server's data stream is compressed (unless maybe if the client
	// is asked to also compress with a DO command ?)
	me.ProcessBytes(data)
}

// Send a bytes array (raw) to the client
func (me *Telnet) TelnetSendBytes(bytes ...byte) {
	me.SendRaw(bytes)
}

// Send an iac command
func (me *Telnet) TelnetSendIac(cmd byte) {
	me.TelnetSendBytes(TELNET_IAC, cmd)
}

// Send negotiation. Currently rfc1143 is not implemented, so beware of
// server client loops. The simplest way to avoid those is to never answer any
// client requests, only send server requests.
func (me *Telnet) TelnetSendNegotiate(cmd byte, telopt byte) {
	me.TelnetSendBytes(TELNET_IAC, cmd, telopt)
}

// Send non-command data (escapes IAC bytes)
func (me *Telnet) TelnetSend(buffer []byte) {
	me.SendEscaped(buffer)
}

// send subnegotiation header
func (me *Telnet) TelnetBeginSubnegotiation(telopt byte) {
	me.TelnetSendBytes(TELNET_IAC, TELNET_SB, telopt)
}

// send subnegotiation ending
func (me *Telnet) TelnetEndSubnegotiation() {
	me.TelnetSendBytes(TELNET_IAC, TELNET_SE)
}

// Send complete subnegotiation
func (me *Telnet) TelnetSubnegotiation(telopt byte, buffer []byte) {
	me.TelnetBeginSubnegotiation(telopt)
	if buffer != nil {
		me.TelnetSend(buffer)
	}
	me.TelnetEndSubnegotiation()
}

// Ask client to start accepting compress2 compression
func (me *Telnet) TelnetBeginCompress2() {
	me.TelnetSendBytes(TELNET_IAC, TELNET_SB, TELNET_TELOPT_COMPRESS2, TELNET_IAC, TELNET_SE)
	me.compress = true
}

// Send formatted data to the client
func (me *Telnet) TelnetRawPrintf(format string, args ...interface{}) {
	buf := fmt.Sprintf(format, args...)
	me.TelnetSend([]byte(buf))
}

const CRLF = "\r\n"
const CRNUL = "\r\000"

// send formatted data with \r and \n translation in addition to IAC IAC
// escaping
func (me *Telnet) TelnetPrintf(format string, args ...interface{}) {
	buf := fmt.Sprintf(format, args...)
	buf = strings.Replace(buf, "\r", CRNUL, -1)
	buf = strings.Replace(buf, "\n", CRLF, -1)
	me.TelnetSend([]byte(buf))
}

// NEW-ENVIRON subnegotation
func (me *Telnet) TelnetNewenviron(cmd []byte) {
	me.TelnetSubnegotiation(TELNET_TELOPT_NEW_ENVIRON, cmd)
}

// send TERMINAL-TYPE SEND command
func (me *Telnet) TelnetTTypeSend() {
	me.TelnetSendBytes(TELNET_IAC, TELNET_SB, TELNET_TELOPT_TTYPE, TELNET_TTYPE_SEND, TELNET_IAC, TELNET_SE)
}

// send TERMINAL-TYPE IS command
func (me *Telnet) TelnetTTypeIS(ttype string) {
	me.TelnetSendBytes(TELNET_IAC, TELNET_SB, TELNET_TELOPT_TTYPE, TELNET_TTYPE_IS)
	me.TelnetSend([]byte(ttype))
}

// send MSSP data
func (me *Telnet) TelnetSendMSSP(mssp map[string]string) {
	var buf []byte
	for key, val := range mssp {
		buf = append(buf, TELNET_MSSP_VAR)
		buf = append(buf, key...)
		buf = append(buf, TELNET_MSSP_VAL)
		buf = append(buf, val...)
	}
	me.TelnetSubnegotiation(TELNET_TELOPT_MSSP, buf)
}