package door

import (
	"bytes"
	"log"
	"sync"
	"syscall"
)

// OS Specific Write
// This assumes that d.writerMutex is locked.

type OSWriter struct {
	Mutex              sync.Mutex // Writer mutex
	Closed             bool
	Handle             int
	TranslateNL        bool
	TranslateToUnicode bool
	nlBuffer           *bytes.Buffer
	uniBuffer          *bytes.Buffer
}

func (ow *OSWriter) Init(d *Door) {
	ow.Closed = false
	ow.Handle = d.Config.Comm_handle
	ow.TranslateNL = true // Yes, translate NL => CR+NL
	ow.nlBuffer = &bytes.Buffer{}
}

func (ow *OSWriter) CP437toUnicode(output []byte) []byte {
	if ow.uniBuffer == nil {
		ow.uniBuffer = &bytes.Buffer{}
	}
	return ow.uniBuffer.Bytes()
}

func (ow *OSWriter) NewLines(output []byte) []byte {
	var pos, nextpos int
	ow.nlBuffer.Reset()

	for pos != -1 {
		nextpos = bytes.Index(output[pos:], []byte{'\n'})
		if nextpos != -1 {
			nextpos += pos
			// Something to do
			ow.nlBuffer.Write(output[pos:nextpos])
			nextpos++
			pos = nextpos
			ow.nlBuffer.Write([]byte("\r\n"))
		} else {
			ow.nlBuffer.Write(output[pos:])
			pos = nextpos // -1
		}
	}
	// log.Printf(">> %q\n", ow.nlBuffer.Bytes())
	return ow.nlBuffer.Bytes()
}

// The low-lever writer function
func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
	var buff []byte = buffer

	if DEBUG_DOOR {
		if ow.Mutex.TryLock() {
			log.Panic("OSWrite: mutex was NOT locked.")
		}
	}

	// Filters (!)

	if ow.TranslateNL {
		buff = ow.NewLines(buff)
	}

	n, err := syscall.Write(ow.Handle, buff)
	if (err != nil) || (n != len(buff)) {
		if !ow.Closed {
			ow.Closed = true
			// Don't need to close reader, it will close itself.
			// It knows when the caller is gone before the writer ever will!
		}
	}
	return n, err
}

func (ow *OSWriter) Write(buffer []byte) (int, error) {
	ow.Mutex.Lock()
	defer ow.Mutex.Unlock()
	if ow.Closed {
		return 0, ErrDisconnected
	}

	// var output bytes.Buffer
	// output.Write(buffer)
	// Where should this be done?  (I think in here)
	// TO FIX: TO DO:
	/*
		if bytes.HasSuffix(buffer, []byte(RestorePos)) {
			output.WriteString(Color(d.LastColor))
			// output += Color(d.LastColor)
		} else {
			d.UpdateLastColor(output, &d.LastColor)
		}
	*/
	return ow.OSWrite(buffer)
}

func (ow *OSWriter) Stop() {
	ow.Mutex.Lock()
	defer ow.Mutex.Unlock()
	ow.Closed = true
}

// Safe way to check if OSWriter is closed
func (ow *OSWriter) IsClosed() bool {
	ow.Mutex.Lock()
	defer ow.Mutex.Unlock()
	return ow.Closed
}

// deprecated
/*
func (d *Door) OSWrite(buffer []byte) {
	if d.WriterClosed {
		return
	}

	if DEBUG_DOOR {
		if d.writerMutex.TryLock() {
			log.Panicln("OSWrite: writerMutex was NOT locked.")
		}
	}


	n, err := syscall.Write(d.Config.Comm_handle, buffer)
	if (err != nil) || (n != len(buffer)) {
		if !d.WriterClosed {
			d.WriterClosed = true
		}
	}
}
*/

// Deprecated
// This is the writer go routine.

/*
// The parts of interest that I'm holding off on implementing for right now.

	if strings.HasSuffix(output, RestorePos) {
		output += Color(d.LastColor)

	} else {
		d.UpdateLastColor(output, &d.LastColor)
	}

	buffer := []byte(output)

	// n, err := low_write(handle, buffer)

	n, err := syscall.Write(handle, buffer)
	if (err != nil) || (n != len(buffer)) {
		log.Println("closeChannel")
		Closed = true
		d.writerMutex.Lock()
		if !d.WriterClosed {
			d.WriterClosed = true
			// close(d.writerChannel)
		}
		d.writerMutex.Unlock()
	}
*/