// SPDX-FileCopyrightText: 2023 The Pion community <https://pion.ly>
// SPDX-License-Identifier: MIT

package handshake

import (
	

	
	
)

/*
MessageClientHello is for when a client first connects to a server it is
required to send the client hello as its first message.  The client can also send a
client hello in response to a hello request or on its own
initiative in order to renegotiate the security parameters in an
existing connection.
*/
type MessageClientHello struct {
	Version protocol.Version
	Random  Random
	Cookie  []byte

	SessionID []byte

	CipherSuiteIDs     []uint16
	CompressionMethods []*protocol.CompressionMethod
	Extensions         []extension.Extension
}

const handshakeMessageClientHelloVariableWidthStart = 34

// Type returns the Handshake Type
func ( MessageClientHello) () Type {
	return TypeClientHello
}

// Marshal encodes the Handshake
func ( *MessageClientHello) () ([]byte, error) {
	if len(.Cookie) > 255 {
		return nil, errCookieTooLong
	}

	 := make([]byte, handshakeMessageClientHelloVariableWidthStart)
	[0] = .Version.Major
	[1] = .Version.Minor

	 := .Random.MarshalFixed()
	copy([2:], [:])

	 = append(, byte(len(.SessionID)))
	 = append(, .SessionID...)

	 = append(, byte(len(.Cookie)))
	 = append(, .Cookie...)
	 = append(, encodeCipherSuiteIDs(.CipherSuiteIDs)...)
	 = append(, protocol.EncodeCompressionMethods(.CompressionMethods)...)

	,  := extension.Marshal(.Extensions)
	if  != nil {
		return nil, 
	}

	return append(, ...), nil
}

// Unmarshal populates the message from encoded data
func ( *MessageClientHello) ( []byte) error {
	if len() < 2+RandomLength {
		return errBufferTooSmall
	}

	.Version.Major = [0]
	.Version.Minor = [1]

	var  [RandomLength]byte
	copy([:], [2:])
	.Random.UnmarshalFixed()

	// rest of packet has variable width sections
	 := handshakeMessageClientHelloVariableWidthStart

	++
	if len() <=  {
		return errBufferTooSmall
	}
	 := int([-1])
	if len() <= + {
		return errBufferTooSmall
	}
	.SessionID = append([]byte{}, [:+]...)
	 += len(.SessionID)

	++
	if len() <=  {
		return errBufferTooSmall
	}
	 = int([-1])
	if len() <= + {
		return errBufferTooSmall
	}
	.Cookie = append([]byte{}, [:+]...)
	 += len(.Cookie)

	// Cipher Suites
	if len() <  {
		return errBufferTooSmall
	}
	,  := decodeCipherSuiteIDs([:])
	if  != nil {
		return 
	}
	.CipherSuiteIDs = 
	if len() < +2 {
		return errBufferTooSmall
	}
	 += int(binary.BigEndian.Uint16([:])) + 2

	// Compression Methods
	if len() <  {
		return errBufferTooSmall
	}
	,  := protocol.DecodeCompressionMethods([:])
	if  != nil {
		return 
	}
	.CompressionMethods = 
	if len() <  {
		return errBufferTooSmall
	}
	 += int([]) + 1

	// Extensions
	,  := extension.Unmarshal([:])
	if  != nil {
		return 
	}
	.Extensions = 
	return nil
}