package ws

import (
	
	
)

// Header size length bounds in bytes.
const (
	MaxHeaderSize = 14
	MinHeaderSize = 2
)

const (
	bit0 = 0x80
	bit1 = 0x40
	bit2 = 0x20
	bit3 = 0x10
	bit4 = 0x08
	bit5 = 0x04
	bit6 = 0x02
	bit7 = 0x01

	len7  = int64(125)
	len16 = int64(^(uint16(0)))
	len64 = int64(^(uint64(0)) >> 1)
)

// HeaderSize returns number of bytes that are needed to encode given header.
// It returns -1 if header is malformed.
func ( Header) ( int) {
	switch {
	case .Length < 126:
		 = 2
	case .Length <= len16:
		 = 4
	case .Length <= len64:
		 = 10
	default:
		return -1
	}
	if .Masked {
		 += len(.Mask)
	}
	return 
}

// WriteHeader writes header binary representation into w.
func ( io.Writer,  Header) error {
	// Make slice of bytes with capacity 14 that could hold any header.
	 := make([]byte, MaxHeaderSize)

	if .Fin {
		[0] |= bit0
	}
	[0] |= .Rsv << 4
	[0] |= byte(.OpCode)

	var  int
	switch {
	case .Length <= len7:
		[1] = byte(.Length)
		 = 2

	case .Length <= len16:
		[1] = 126
		binary.BigEndian.PutUint16([2:4], uint16(.Length))
		 = 4

	case .Length <= len64:
		[1] = 127
		binary.BigEndian.PutUint64([2:10], uint64(.Length))
		 = 10

	default:
		return ErrHeaderLengthUnexpected
	}

	if .Masked {
		[1] |= bit0
		 += copy([:], .Mask[:])
	}

	,  := .Write([:])

	return 
}

// WriteFrame writes frame binary representation into w.
func ( io.Writer,  Frame) error {
	 := WriteHeader(, .Header)
	if  != nil {
		return 
	}
	_,  = .Write(.Payload)
	return 
}

// MustWriteFrame is like WriteFrame but panics if frame can not be read.
func ( io.Writer,  Frame) {
	if  := WriteFrame(, );  != nil {
		panic()
	}
}