// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build go1.21

package quic

import (
	"encoding/binary"
	"net/netip"
	"time"
)

// transportParameters transferred in the quic_transport_parameters TLS extension.
// https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2
type transportParameters struct {
	originalDstConnID              []byte
	maxIdleTimeout                 time.Duration
	statelessResetToken            []byte
	maxUDPPayloadSize              int64
	initialMaxData                 int64
	initialMaxStreamDataBidiLocal  int64
	initialMaxStreamDataBidiRemote int64
	initialMaxStreamDataUni        int64
	initialMaxStreamsBidi          int64
	initialMaxStreamsUni           int64
	ackDelayExponent               int8
	maxAckDelay                    time.Duration
	disableActiveMigration         bool
	preferredAddrV4                netip.AddrPort
	preferredAddrV6                netip.AddrPort
	preferredAddrConnID            []byte
	preferredAddrResetToken        []byte
	activeConnIDLimit              int64
	initialSrcConnID               []byte
	retrySrcConnID                 []byte
}

const (
	defaultParamMaxUDPPayloadSize       = 65527
	defaultParamAckDelayExponent        = 3
	defaultParamMaxAckDelayMilliseconds = 25
	defaultParamActiveConnIDLimit       = 2
)

// defaultTransportParameters is initialized to the RFC 9000 default values.
func defaultTransportParameters() transportParameters {
	return transportParameters{
		maxUDPPayloadSize: defaultParamMaxUDPPayloadSize,
		ackDelayExponent:  defaultParamAckDelayExponent,
		maxAckDelay:       defaultParamMaxAckDelayMilliseconds * time.Millisecond,
		activeConnIDLimit: defaultParamActiveConnIDLimit,
	}
}

const (
	paramOriginalDestinationConnectionID = 0x00
	paramMaxIdleTimeout                  = 0x01
	paramStatelessResetToken             = 0x02
	paramMaxUDPPayloadSize               = 0x03
	paramInitialMaxData                  = 0x04
	paramInitialMaxStreamDataBidiLocal   = 0x05
	paramInitialMaxStreamDataBidiRemote  = 0x06
	paramInitialMaxStreamDataUni         = 0x07
	paramInitialMaxStreamsBidi           = 0x08
	paramInitialMaxStreamsUni            = 0x09
	paramAckDelayExponent                = 0x0a
	paramMaxAckDelay                     = 0x0b
	paramDisableActiveMigration          = 0x0c
	paramPreferredAddress                = 0x0d
	paramActiveConnectionIDLimit         = 0x0e
	paramInitialSourceConnectionID       = 0x0f
	paramRetrySourceConnectionID         = 0x10
)

func marshalTransportParameters(p transportParameters) []byte {
	var b []byte
	if v := p.originalDstConnID; v != nil {
		b = appendVarint(b, paramOriginalDestinationConnectionID)
		b = appendVarintBytes(b, v)
	}
	if v := uint64(p.maxIdleTimeout / time.Millisecond); v != 0 {
		b = appendVarint(b, paramMaxIdleTimeout)
		b = appendVarint(b, uint64(sizeVarint(v)))
		b = appendVarint(b, uint64(v))
	}
	if v := p.statelessResetToken; v != nil {
		b = appendVarint(b, paramStatelessResetToken)
		b = appendVarintBytes(b, v)
	}
	if v := p.maxUDPPayloadSize; v != defaultParamMaxUDPPayloadSize {
		b = appendVarint(b, paramMaxUDPPayloadSize)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialMaxData; v != 0 {
		b = appendVarint(b, paramInitialMaxData)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialMaxStreamDataBidiLocal; v != 0 {
		b = appendVarint(b, paramInitialMaxStreamDataBidiLocal)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialMaxStreamDataBidiRemote; v != 0 {
		b = appendVarint(b, paramInitialMaxStreamDataBidiRemote)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialMaxStreamDataUni; v != 0 {
		b = appendVarint(b, paramInitialMaxStreamDataUni)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialMaxStreamsBidi; v != 0 {
		b = appendVarint(b, paramInitialMaxStreamsBidi)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialMaxStreamsUni; v != 0 {
		b = appendVarint(b, paramInitialMaxStreamsUni)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.ackDelayExponent; v != defaultParamAckDelayExponent {
		b = appendVarint(b, paramAckDelayExponent)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := uint64(p.maxAckDelay / time.Millisecond); v != defaultParamMaxAckDelayMilliseconds {
		b = appendVarint(b, paramMaxAckDelay)
		b = appendVarint(b, uint64(sizeVarint(v)))
		b = appendVarint(b, v)
	}
	if p.disableActiveMigration {
		b = appendVarint(b, paramDisableActiveMigration)
		b = append(b, 0) // 0-length value
	}
	if p.preferredAddrConnID != nil {
		b = append(b, paramPreferredAddress)
		b = appendVarint(b, uint64(4+2+16+2+1+len(p.preferredAddrConnID)+16))
		b = append(b, p.preferredAddrV4.Addr().AsSlice()...)           // 4 bytes
		b = binary.BigEndian.AppendUint16(b, p.preferredAddrV4.Port()) // 2 bytes
		b = append(b, p.preferredAddrV6.Addr().AsSlice()...)           // 16 bytes
		b = binary.BigEndian.AppendUint16(b, p.preferredAddrV6.Port()) // 2 bytes
		b = appendUint8Bytes(b, p.preferredAddrConnID)                 // 1 byte + len(conn_id)
		b = append(b, p.preferredAddrResetToken...)                    // 16 bytes
	}
	if v := p.activeConnIDLimit; v != defaultParamActiveConnIDLimit {
		b = appendVarint(b, paramActiveConnectionIDLimit)
		b = appendVarint(b, uint64(sizeVarint(uint64(v))))
		b = appendVarint(b, uint64(v))
	}
	if v := p.initialSrcConnID; v != nil {
		b = appendVarint(b, paramInitialSourceConnectionID)
		b = appendVarintBytes(b, v)
	}
	if v := p.retrySrcConnID; v != nil {
		b = appendVarint(b, paramRetrySourceConnectionID)
		b = appendVarintBytes(b, v)
	}
	return b
}

func unmarshalTransportParams(params []byte) (transportParameters, error) {
	p := defaultTransportParameters()
	for len(params) > 0 {
		id, n := consumeVarint(params)
		if n < 0 {
			return p, localTransportError{code: errTransportParameter}
		}
		params = params[n:]
		val, n := consumeVarintBytes(params)
		if n < 0 {
			return p, localTransportError{code: errTransportParameter}
		}
		params = params[n:]
		n = 0
		switch id {
		case paramOriginalDestinationConnectionID:
			p.originalDstConnID = val
			n = len(val)
		case paramMaxIdleTimeout:
			var v uint64
			v, n = consumeVarint(val)
			// If this is unreasonably large, consider it as no timeout to avoid
			// time.Duration overflows.
			if v > 1<<32 {
				v = 0
			}
			p.maxIdleTimeout = time.Duration(v) * time.Millisecond
		case paramStatelessResetToken:
			if len(val) != 16 {
				return p, localTransportError{code: errTransportParameter}
			}
			p.statelessResetToken = val
			n = 16
		case paramMaxUDPPayloadSize:
			p.maxUDPPayloadSize, n = consumeVarintInt64(val)
			if p.maxUDPPayloadSize < 1200 {
				return p, localTransportError{code: errTransportParameter}
			}
		case paramInitialMaxData:
			p.initialMaxData, n = consumeVarintInt64(val)
		case paramInitialMaxStreamDataBidiLocal:
			p.initialMaxStreamDataBidiLocal, n = consumeVarintInt64(val)
		case paramInitialMaxStreamDataBidiRemote:
			p.initialMaxStreamDataBidiRemote, n = consumeVarintInt64(val)
		case paramInitialMaxStreamDataUni:
			p.initialMaxStreamDataUni, n = consumeVarintInt64(val)
		case paramInitialMaxStreamsBidi:
			p.initialMaxStreamsBidi, n = consumeVarintInt64(val)
			if p.initialMaxStreamsBidi > maxStreamsLimit {
				return p, localTransportError{code: errTransportParameter}
			}
		case paramInitialMaxStreamsUni:
			p.initialMaxStreamsUni, n = consumeVarintInt64(val)
			if p.initialMaxStreamsUni > maxStreamsLimit {
				return p, localTransportError{code: errTransportParameter}
			}
		case paramAckDelayExponent:
			var v uint64
			v, n = consumeVarint(val)
			if v > 20 {
				return p, localTransportError{code: errTransportParameter}
			}
			p.ackDelayExponent = int8(v)
		case paramMaxAckDelay:
			var v uint64
			v, n = consumeVarint(val)
			if v >= 1<<14 {
				return p, localTransportError{code: errTransportParameter}
			}
			p.maxAckDelay = time.Duration(v) * time.Millisecond
		case paramDisableActiveMigration:
			p.disableActiveMigration = true
		case paramPreferredAddress:
			if len(val) < 4+2+16+2+1 {
				return p, localTransportError{code: errTransportParameter}
			}
			p.preferredAddrV4 = netip.AddrPortFrom(
				netip.AddrFrom4(*(*[4]byte)(val[:4])),
				binary.BigEndian.Uint16(val[4:][:2]),
			)
			val = val[4+2:]
			p.preferredAddrV6 = netip.AddrPortFrom(
				netip.AddrFrom16(*(*[16]byte)(val[:16])),
				binary.BigEndian.Uint16(val[16:][:2]),
			)
			val = val[16+2:]
			var nn int
			p.preferredAddrConnID, nn = consumeUint8Bytes(val)
			if nn < 0 {
				return p, localTransportError{code: errTransportParameter}
			}
			val = val[nn:]
			if len(val) != 16 {
				return p, localTransportError{code: errTransportParameter}
			}
			p.preferredAddrResetToken = val
			val = nil
		case paramActiveConnectionIDLimit:
			p.activeConnIDLimit, n = consumeVarintInt64(val)
			if p.activeConnIDLimit < 2 {
				return p, localTransportError{code: errTransportParameter}
			}
		case paramInitialSourceConnectionID:
			p.initialSrcConnID = val
			n = len(val)
		case paramRetrySourceConnectionID:
			p.retrySrcConnID = val
			n = len(val)
		default:
			n = len(val)
		}
		if n != len(val) {
			return p, localTransportError{code: errTransportParameter}
		}
	}
	return p, nil
}