package socket

import (
	"tunnel/pkg/server/env"
	"tunnel/pkg/server/queue"
)

type deferSocket struct {
	S
}

type deferChannel struct {
	s *deferSocket
	c chan Channel
	e env.Env
}

func newDeferSocket(proto, addr string) (S, error) {
	s, err := newDialSocket(proto, addr)
	if err != nil {
		return s, err
	}

	return &deferSocket{s}, nil
}

func (s *deferSocket) Open(env env.Env) (Channel, error) {
	c := &deferChannel{
		s: s,
		c: make(chan Channel),
		e: env,
	}

	return c, nil
}

func (c *deferChannel) String() string {
	return "defer"
}

func (c *deferChannel) Send(wq queue.Q) error {
	if x := <-c.c; x == nil {
		return nil
	} else {
		return x.Send(wq)
	}
}

func (c *deferChannel) Recv(rq queue.Q) error {
	b := <-rq
	if b == nil {
		close(c.c)
		return nil
	}

	x, err := c.s.S.Open(c.e)
	if err != nil {
		close(c.c)
		return err
	}

	c.c <- x

	q := queue.New()

	go func() {
		q <- b
		queue.Copy(rq, q)
		close(q)
	}()

	defer q.Dry()

	return x.Recv(q)
}

/* TODO */
func (c *deferChannel) Close() error {
	return nil
}