package hcl

/*
#include <hcl.h>
#include <hcl-utl.h>
*/
import "C"

import (
	//	"bufio"
	//	"io"
	"bufio"
	"io"
	"os"
	"sync"
	"unsafe"
	// "sync"
	// "unsafe"
)

type IOHandle struct {
	file *os.File
	ioif interface{}
}

type IOHandleTable struct {
	mtx        sync.Mutex
	handles    []IOHandle
	free_slots []int
}

func (io *IOHandleTable) add_io_handle(f *os.File, ioif interface{}) int {
	io.mtx.Lock()
	defer io.mtx.Unlock()

	var n int = len(io.free_slots)

	if n <= 0 { // no free slots
		io.handles = append(io.handles, IOHandle{file: f, ioif: ioif})
		return len(io.handles) - 1
	} else {
		var slot int
		n--
		slot = io.free_slots[n]
		io.free_slots = io.free_slots[:n]
		io.handles[slot].file = f
		io.handles[slot].ioif = ioif
		return slot
	}
}

func (io *IOHandleTable) del_io_handle(slot int) IOHandle {
	var (
		h IOHandle
		n int
	)

	io.mtx.Lock()
	defer io.mtx.Unlock()

	h = io.handles[slot]
	io.handles[slot].file = nil
	io.handles[slot].ioif = nil

	n = len(io.handles)
	if slot == n-1 {
		io.handles = io.handles[:n-1]
	} else {
		io.free_slots = append(io.free_slots, slot)
	}

	return h
}

func (io *IOHandleTable) slot_to_io_handle(slot int) IOHandle {
	io.mtx.Lock()
	defer io.mtx.Unlock()
	return io.handles[slot]
}

var io_tab IOHandleTable = IOHandleTable{}

//export hcl_go_read_handler
func hcl_go_read_handler(c *C.hcl_t, cmd C.hcl_iocmd_t, arg unsafe.Pointer) C.int {
	var (
		g   *HCL
		err error
	)

	g = c_to_go(c)

	switch cmd {
	case C.HCL_IO_OPEN:
		var (
			ioarg         *C.hcl_iosrarg_t
			name          string
			includer_name string
			fd            int
		)

		ioarg = (*C.hcl_iosrarg_t)(arg)
		if ioarg.name == nil { // main stream when it's not feed based.
			name = ""
		} else {
			var k []rune = ucstr_to_rune_slice(ioarg.name)
			name = string(k)
		}

		if ioarg.includer == nil || ioarg.includer.name == nil {
			includer_name = ""
		} else {
			var k []rune = ucstr_to_rune_slice(ioarg.includer.name)
			includer_name = string(k)
		}

		fd, err = g.io.r.Open(g, name, includer_name)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}

		ioarg.handle = unsafe.Pointer(uintptr(fd))
		return 0

	case C.HCL_IO_CLOSE:
		var ioarg *C.hcl_iosrarg_t = (*C.hcl_iosrarg_t)(arg)
		g.io.r.Close(int(uintptr(ioarg.handle)))
		return 0

	case C.HCL_IO_READ:
		var (
			ioarg *C.hcl_iosrarg_t
			n     int
			i     int
			buf   []rune
		)
		ioarg = (*C.hcl_iosrarg_t)(arg)

		buf = make([]rune, 1024) // TODO:  different size...
		n, err = g.io.r.Read(int(uintptr(ioarg.handle)), buf)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}

		for i = 0; i < n; i++ { // TODO: use a proper conversion when the rune size is different from hio_uch_t
			ioarg.buf[i] = C.hcl_uch_t(buf[i])
		}
		ioarg.xlen = C.hcl_oow_t(n)
		return 0
	}

	C.hcl_seterrnum(c, C.HCL_ENOIMPL)
	return -1
}

//export hcl_go_scan_handler
func hcl_go_scan_handler(c *C.hcl_t, cmd C.hcl_iocmd_t, arg unsafe.Pointer) C.int {
	var (
		g   *HCL
		err error
	)

	g = c_to_go(c)

	switch cmd {
	case C.HCL_IO_OPEN:
		err = g.io.s.Open(g)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}

		// we don't need to set ioarg.handle because the c object to go object
		// mapping has been established and it doesn't handle multiple streams
		return 0

	case C.HCL_IO_CLOSE:
		g.io.s.Close()
		return 0

	case C.HCL_IO_READ:
		var (
			ioarg *C.hcl_ioinarg_t
			n     int
			err   error
			buf   []rune
		)
		ioarg = (*C.hcl_ioinarg_t)(arg)

		buf = make([]rune, 1024) // TODO:  different size...
		n, err = g.io.s.Read(buf)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}
		ioarg.xlen = C.ulong(n)
		return 0
	}

	C.hcl_seterrnum(c, C.HCL_ENOIMPL)
	return -1
}

//export hcl_go_print_handler
func hcl_go_print_handler(c *C.hcl_t, cmd C.hcl_iocmd_t, arg unsafe.Pointer) C.int {
	var (
		g   *HCL
		err error
	)

	g = c_to_go(c)

	switch cmd {
	case C.HCL_IO_OPEN:
		err = g.io.p.Open(g)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}

		// we don't need to set ioarg.handle because the c object to go object
		// mapping has been established and it doesn't handle multiple streams
		return 0

	case C.HCL_IO_CLOSE:
		g.io.p.Close()
		return 0

	case C.HCL_IO_WRITE:
		var (
			ioarg *C.hcl_iooutarg_t
			data  []rune
			err   error
		)
		ioarg = (*C.hcl_iooutarg_t)(arg)
		data = uchars_to_rune_slice((*C.hcl_uch_t)(ioarg.ptr), uintptr(ioarg.len))
		err = g.io.p.Write(data)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}
		ioarg.xlen = C.hcl_oow_t(len(data))
		return 0

	case C.HCL_IO_WRITE_BYTES:
		var (
			ioarg *C.hcl_iooutarg_t
			data  []byte
			err   error
		)
		ioarg = (*C.hcl_iooutarg_t)(arg)
		data = unsafe.Slice((*byte)(ioarg.ptr), ioarg.len)
		err = g.io.p.WriteBytes(data)
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}
		ioarg.xlen = C.hcl_oow_t(len(data))
		return 0

	case C.HCL_IO_FLUSH:
		var err error = g.io.p.Flush()
		if err != nil {
			C.hcl_seterrbmsg(c, C.HCL_ENOIMPL, C.CString(err.Error()))
			return -1
		}
		return 0
	}

	C.hcl_seterrnum(c, C.HCL_ENOIMPL)
	return -1
}

// ------------------------------------------------------
type ReadFileHandler struct {
	g *HCL
}

func (p *ReadFileHandler) Open(g *HCL, name string, includer_name string) (int, error) {
	var (
		f   *os.File
		r   *bufio.Reader
		fd  int
		err error
	)

	if name == "" {
		f = os.Stdin
	} else {
		f, err = os.Open(name)
		if err != nil {
			return -1, err
		}
	}

	r = bufio.NewReader(f)
	fd = io_tab.add_io_handle(f, r)

	p.g = g
	return fd, nil
}

func (p *ReadFileHandler) Close(fd int) {
	var hnd IOHandle = io_tab.slot_to_io_handle(fd)
	if hnd.file != nil {
		if hnd.file != os.Stdout && hnd.file != os.Stderr {
			hnd.file.Close()
		}
		hnd.file = nil
		hnd.ioif = nil
	}
}

func (p *ReadFileHandler) Read(fd int, buf []rune) (int, error) {
	var (
		hnd IOHandle
		i   int
		c   rune
		r   *bufio.Reader
		err error
	)

	hnd = io_tab.slot_to_io_handle(fd)
	r, _ = hnd.ioif.(*bufio.Reader)
	for i = 0; i < len(buf); i++ {
		c, _, err = r.ReadRune()
		if err == io.EOF {
			break
		} else if err != nil {
			return -1, err
		}

		buf[i] = c
	}

	return i, nil
}

// ------------------------------------------------------
type ScanFileHandler struct {
	g *HCL
	f *os.File
	r *bufio.Reader
}

func (p *ScanFileHandler) Open(g *HCL) error {
	var (
		f *os.File
	//	err error
	)

	f = os.Stdin
	//f, err = os.Open("/dev/stdin")
	//if err != nil {
	//	return err
	//}

	p.r = bufio.NewReader(f)
	p.f = f
	p.g = g

	return nil
}

func (p *ScanFileHandler) Close() {
	if p.f != nil {
		if p.f != os.Stdout && p.f != os.Stderr {
			p.f.Close()
		}
		p.f = nil
		p.r = nil
	}
}

func (p *ScanFileHandler) Read(buf []rune) (int, error) {
	var (
		i   int
		c   rune
		err error
	)

	// flush all pending print out before reading
	p.g.io.p.Flush()

	for i = 0; i < len(buf); i++ {
		c, _, err = p.r.ReadRune()
		if err == io.EOF {
			break
		} else if err != nil {
			return -1, err
		}

		buf[i] = c
	}

	return i, nil
}

// ------------------------------------------------------

type PrintFileHandler struct {
	f *os.File
	w *bufio.Writer
}

func (p *PrintFileHandler) Open(g *HCL) error {
	var (
		f *os.File
	//	err error
	)

	//		f, err = os.OpenFile("/dev/stdout", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	//		if err != nil {
	//			return err
	//		}

	f = os.Stdout

	p.w = bufio.NewWriter(f)
	p.f = f

	//fmt.Fprintf(os.Stderr, "XXXXXXXXXX open porint\n")
	return nil
}

func (p *PrintFileHandler) Close() {

	//fmt.Fprintf(os.Stderr, "XXXXXXXXXX close porint\n")
	if p.f != nil {
		if p.f != os.Stdout && p.f != os.Stderr {
			p.f.Close()
		}
		p.f = nil
		p.w = nil
	}
}

func (p *PrintFileHandler) Write(data []rune) error {
	var err error

	//fmt.Fprintf(os.Stderr, "XXXXXXXXXX write porint\n")
	_, err = p.w.WriteString(string(data))
	p.w.Flush() // TODO: is this needed?
	return err
}

func (p *PrintFileHandler) WriteBytes(data []byte) error {
	var err error

	//fmt.Fprintf(os.Stderr, "XXXXXXXXXX write porint\n")
	_, err = p.w.Write(data)
	p.w.Flush() // TODO: is this needed?
	return err
}

func (p *PrintFileHandler) Flush() error {
	//fmt.Fprintf(os.Stderr, "XXXXXXXXXX flush porint\n")
	return p.w.Flush()
}