/*
Copyright 2022 CAcert Inc.
SPDX-License-Identifier: Apache-2.0

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Package protocol handles the protocol message marshaling and unmarshalling.
package protocol

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"time"

	"github.com/justincpresley/go-cobs"
	"github.com/sirupsen/logrus"

	"git.cacert.org/cacert-gosigner/pkg/messages"
)

const CobsDelimiter = 0x00

type Command struct {
	Announce *messages.CommandAnnounce
	Command  interface{}
}

func (c *Command) String() string {
	return fmt.Sprintf("Cmd[announce={%s}, data={%s}]", c.Announce, c.Command)
}

type Response struct {
	Announce *messages.ResponseAnnounce
	Response interface{}
}

func (r *Response) String() string {
	return fmt.Sprintf("Rsp[announce={%s}, data={%s}]", r.Announce, r.Response)
}

// Handler is responsible for parsing incoming frames and calling commands
type Handler interface {
	// HandleCommandAnnounce handles the initial announcement of a command.
	HandleCommandAnnounce([]byte) error
	// HandleCommand handles the command data.
	HandleCommand([]byte) error
	// ResponseAnnounce generates the announcement for a response.
	ResponseAnnounce() ([]byte, error)
	// ResponseData generates the response data.
	ResponseData() ([]byte, error)
}

// Framer handles bytes on the wire by adding or removing framing information.
type Framer interface {
	// ReadFrames reads data frames and publishes unframed data to the channel.
	ReadFrames(io.Reader, chan []byte) error
	// WriteFrames takes data from the channel and writes framed data to the writer.
	WriteFrames(io.Writer, chan []byte) error
}

const bufferSize = 1024
const readInterval = 50 * time.Millisecond

type COBSFramer struct {
	config cobs.Config
	logger *logrus.Logger
}

func NewCOBSFramer(logger *logrus.Logger) *COBSFramer {
	return &COBSFramer{
		config: cobs.Config{SpecialByte: CobsDelimiter, Delimiter: true, EndingSave: true},
		logger: logger,
	}
}

func (c *COBSFramer) ReadFrames(reader io.Reader, frameChan chan []byte) error {
	var (
		err              error
		raw, data, frame []byte
	)

	buffer := &bytes.Buffer{}

	for {
		raw, err = c.readRaw(reader)
		if err != nil {
			close(frameChan)

			return err
		}

		if len(raw) == 0 {
			time.Sleep(readInterval)

			continue
		}

		c.logger.Tracef("read %d raw bytes", len(raw))

		buffer.Write(raw)

		for {
			data, err = buffer.ReadBytes(c.config.SpecialByte)
			if err != nil {
				if errors.Is(err, io.EOF) {
					buffer.Write(data)

					break
				}

				return fmt.Errorf("could not read from buffer: %w", err)
			}

			if err = cobs.Verify(data, c.config); err != nil {
				c.logger.WithError(err).Warnf("skipping invalid frame of %d bytes", len(data))

				break
			}

			frame = cobs.Decode(data, c.config)

			c.logger.Tracef("frame decoded to length %d", len(frame))

			frameChan <- frame
		}

		c.logger.Tracef("read buffer is now %d bytes long", buffer.Len())
	}
}

func (c *COBSFramer) readRaw(reader io.Reader) ([]byte, error) {
	buf := make([]byte, bufferSize)

	count, err := reader.Read(buf)
	if err != nil {
		if errors.Is(err, io.EOF) {
			return []byte{}, nil
		}

		return nil, fmt.Errorf("could not read data: %w", err)
	}

	raw := buf[:count]

	return raw, nil
}

func (c *COBSFramer) WriteFrames(writer io.Writer, frameChan chan []byte) error {
	for {
		frame := <-frameChan

		if frame == nil {
			c.logger.Debug("channel closed")

			return nil
		}

		encoded := cobs.Encode(frame, c.config)

		n, err := io.Copy(writer, bytes.NewReader(encoded))
		if err != nil {
			return fmt.Errorf("cold not write data: %w", err)
		}

		c.logger.Tracef("wrote %d bytes", n)
	}
}