// Callback is the callback, used to update the progress bar as remote.cache
// downloads
func (cb *CacheCallback) Callback(par *dnode.Partial) {
	type Progress struct {
		Progress int        `json:progress`
		Error    kite.Error `json:error`
	}

	// TODO: Why is this an array from Klient? How can this be written cleaner?
	ps := []Progress{{}}
	par.MustUnmarshal(&ps)
	p := ps[0]

	cb.Log.Debug("CacheCallback Progress: %#v", p)

	if p.Error.Message != "" {
		cb.doneErr <- p.Error
	}

	cb.Bar.Set(p.Progress)

	// TODO: Disable the callback here, so that it's impossible to double call
	// the progress after competion - to avoid weird/bad UX and errors.
	if p.Progress == 100 {
		cb.doneErr <- nil
	}
}

func (s *Server) SetSize(d *dnode.Partial) {
	args := d.MustSliceOfLength(2)
	x := args[0].MustFloat64()
	y := args[1].MustFloat64()

	err := s.client.ResizeExecTTY(s.Session, int(y), int(x))
	if err != nil {
		fmt.Println("error resizing", err)
	}
}

// Input is called when some text is written to the terminal.
func (s *Server) Input(d *dnode.Partial) {
	data := d.MustSliceOfLength(1)[0].MustString()

	if s.inputHook != nil {
		s.inputHook()
	}

	// There is no need to protect the Write() with a mutex because
	// Kite Library guarantees that only one message is processed at a time.
	s.in.Write([]byte(data))
}

// newRequest returns a new *Request from the method and arguments passed.
func (c *Client) newRequest(method string, args *dnode.Partial) (*Request, func(interface{}, *Error)) {
	// Parse dnode method arguments: [options]
	var options callOptions
	args.One().MustUnmarshal(&options)

	// Notify the handlers registered with Kite.OnFirstRequest().
	if _, ok := c.session.(*sockjsclient.WebsocketSession); !ok {
		c.firstRequestHandlersNotified.Do(func() {
			c.m.Lock()
			c.Kite = options.Kite
			c.m.Unlock()
			c.LocalKite.callOnFirstRequestHandlers(c)
		})
	}

	request := &Request{
		ID:        utils.RandomString(16),
		Method:    method,
		Args:      options.WithArgs,
		LocalKite: c.LocalKite,
		Client:    c,
		Auth:      options.Auth,
		Context:   cache.NewMemory(),
	}

	// Call response callback function, send back our response
	callFunc := func(result interface{}, err *Error) {
		if options.ResponseCallback.Caller == nil {
			return
		}

		// Only argument to the callback.
		response := Response{
			Result: result,
			Error:  err,
		}

		if err := options.ResponseCallback.Call(response); err != nil {
			c.LocalKite.Log.Error(err.Error())
		}
	}

	return request, callFunc
}

func (r *termHandler) Output(d *dnode.Partial) {
	data := d.MustSliceOfLength(1)[0].MustString()
	r.output <- data
}

// ControlSequence is called when a non-printable key is pressed on the terminal.
func (s *Server) ControlSequence(d *dnode.Partial) {
	data := d.MustSliceOfLength(1)[0].MustString()
	s.controlSequence.Write([]byte(data))
}

func (s *Server) SetSize(d *dnode.Partial) {
	args := d.MustSliceOfLength(2)
	x := args[0].MustFloat64()
	y := args[1].MustFloat64()
	s.setSize(x, y)
}