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
}

func (ow *OSWriter) Init(d *Door) {
	ow.Closed = false
	ow.Handle = d.Config.Comm_handle
}

// The low-lever writer function
func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
	if DEBUG_DOOR {
		if ow.Mutex.TryLock() {
			log.Panic("OSWrite: mutex was NOT locked.")
		}
	}

	n, err := syscall.Write(ow.Handle, buffer)
	if (err != nil) || (n != len(buffer)) {
		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(output.Bytes())
}

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()
	}
*/