module pem

import encoding.base64
import arrays

// `encode_config` encodes the given block into a
// string using the EncodeConfig. It returns an error if `block_type` is undefined
// or if a value in `headers` contains an invalid character ':'
//
// default EncodeConfig values wrap lines at 64 bytes and use '\n' for newlines
pub fn (block Block) encode(config EncodeConfig) !string {
	if block.block_type == '' {
		return error('crypto.pem: `encode` called with undefined `block_type`')
	}
	if block.headers.keys().any(it.contains(':')) || block.headers.values().any(it.contains(':')) {
		return error('crypto.pem: invalid header character `:`')
	}

	// to avoid repeated struct access
	newline := config.line_ending
	length := config.line_length

	mut inner := ''
	if block.headers.len > 0 {
		// Proc-Type must be written first if it is present
		if block.headers['Proc-Type'].len > 0 {
			inner += 'Proc-Type: 4,${block.headers['Proc-Type'][0].trim_string_left('4,')}' +
				newline
		}

		for key, value in block.headers {
			if key == 'Proc-Type' {
				continue
			}

			for _, subvalue in value {
				inner += '${key}: '
				if key.len + subvalue.len < length {
					inner += subvalue
				} else {
					inner += newline + wrap_lines(subvalue, newline, length)
				}
				inner += newline
			}
		}

		inner += newline
	}

	inner += wrap_lines(base64.encode(block.data), newline, length)

	return '${pem_begin}${block.block_type}${pem_eol}${newline}' + '${inner}' +
		'${pem_end}${block.block_type}${pem_eol}'
}

[inline]
fn wrap_lines(str string, newline string, length int) string {
	return arrays.chunk(str.bytes(), length).map(it.bytestr()).join(newline)
}
