package tcp

import (
	"encoding/json"
	"net"
	"net/http"
	"strings"
)

const (
	StatusOK int = 200

	StatusBadRequest   = 400
	StatusUnauthorized = 401
	StatusForbidden    = 403
	StatusNotFound     = 404

	StatusInternalServerError = 500
)

type ResponseHeader struct {
	StatusCode int `json:"status_code"`
}

type Response struct {
	StatusCode int

	Body []byte

	RemoteAddr string
}

func (self *Response) Header() ([]byte, error) {
	b, err := json.Marshal(ResponseHeader{
		StatusCode: self.StatusCode,
	})
	if err != nil {
		return []byte{}, err
	}
	return b, nil
}

type ResponseWriter interface {
	Write([]byte) (int, error)
	WriteHeader(statusCode int)
	SocketSend([]byte) error
	SocketSendString(string) error
}

type ResponseBuilder struct {
	// For socket to send without closing connection
	conn net.Conn

	b          strings.Builder
	statusCode int
}

func NewResponseBuilder(conn net.Conn) *ResponseBuilder {
	return &ResponseBuilder{
		conn: conn,

		statusCode: http.StatusInternalServerError,
	}
}

func (self *ResponseBuilder) Write(b []byte) (int, error) {
	return self.b.Write(b)
}

func (self *ResponseBuilder) WriteHeader(statusCode int) {
	self.statusCode = statusCode
}

func (self *ResponseBuilder) Build(req *Request) *Response {
	return &Response{
		StatusCode: self.statusCode,

		RemoteAddr: req.RemoteAddr,

		Body: []byte(self.b.String()),
	}
}

func (self *ResponseBuilder) SocketSend(b []byte) error {
	return sendFrame(self.conn, b)
}

func (self *ResponseBuilder) SocketSendString(s string) error {
	return self.SocketSend([]byte(s))
}