Sources/CacheAdvance/FileHeader.swift

//
//  Created by Dan Federman on 12/26/19.
//  Copyright © 2019 Dan Federman.
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//

import Foundation

struct FileHeader {
	// MARK: Lifecycle

	init(
		version: UInt8 = FileHeader.version,
		maximumBytes: Bytes,
		overwritesOldMessages: Bool,
		offsetInFileOfOldestMessage: UInt64,
		offsetInFileAtEndOfNewestMessage: UInt64
	) {
		self.version = version
		self.maximumBytes = maximumBytes
		self.overwritesOldMessages = overwritesOldMessages
		self.offsetInFileOfOldestMessage = offsetInFileOfOldestMessage
		self.offsetInFileAtEndOfNewestMessage = offsetInFileAtEndOfNewestMessage
	}

	init?(from data: Data) {
		guard data.count == FileHeader.expectedEndOfHeaderInFile else {
			return nil
		}

		let versionData = data.subdata(in: FileHeader.Field.version.rangeOfFieldInFile)
		let maximumBytesData = data.subdata(in: FileHeader.Field.maximumBytes.rangeOfFieldInFile)
		let overwritesOldMessagesData = data.subdata(in: FileHeader.Field.overwriteOldMessages.rangeOfFieldInFile)
		let offsetInFileOfOldestMessageData = data.subdata(in: FileHeader.Field.offsetInFileOfOldestMessage.rangeOfFieldInFile)
		let offsetInFileAtEndOfNewestMessageData = data.subdata(in: FileHeader.Field.offsetInFileAtEndOfNewestMessage.rangeOfFieldInFile)

		let version = UInt8(versionData)
		let maximumBytes = Bytes(maximumBytesData)
		let overwritesOldMessages = Bool(overwritesOldMessagesData)
		let offsetInFileOfOldestMessage = UInt64(offsetInFileOfOldestMessageData)
		let offsetInFileAtEndOfNewestMessage = UInt64(offsetInFileAtEndOfNewestMessageData)

		self = FileHeader(
			version: version,
			maximumBytes: maximumBytes,
			overwritesOldMessages: overwritesOldMessages,
			offsetInFileOfOldestMessage: offsetInFileOfOldestMessage,
			offsetInFileAtEndOfNewestMessage: offsetInFileAtEndOfNewestMessage
		)
	}

	// MARK: Internal

	let version: UInt8
	let maximumBytes: Bytes
	let overwritesOldMessages: Bool
	let offsetInFileOfOldestMessage: UInt64
	let offsetInFileAtEndOfNewestMessage: UInt64

	var asData: Data {
		Field.allCases.reduce(Data()) { header, field in
			header + data(for: field)
		}
	}

	/// The expected version of the header.
	/// Whenever there is a breaking change to the header format, update this value.
	static let version: UInt8 = 1

	/// Calculates the offset in the file where the header should end.
	static let expectedEndOfHeaderInFile = Field(rawValue: Field.allCases.endIndex)!.expectedEndOfFieldInFile

	func data(for field: Field) -> Data {
		switch field {
		case .version:
			Data(version)
		case .maximumBytes:
			Data(maximumBytes)
		case .overwriteOldMessages:
			Data(overwritesOldMessages)
		case .offsetInFileOfOldestMessage:
			Data(offsetInFileOfOldestMessage)
		case .offsetInFileAtEndOfNewestMessage:
			Data(offsetInFileAtEndOfNewestMessage)
		case .reservedSpace:
			Data(repeating: 0, count: field.storageLength)
		}
	}

	enum Field: Int, CaseIterable {
		// Header format:
		// [headerVersion:UInt8][maximumBytes:UInt64][overwritesOldMessages:Bool][offsetInFileOfOldestMessage:UInt64][offsetInFileAtEndOfNewestMessage:UInt64][reservedSpace]

		case version = 1
		case maximumBytes
		case overwriteOldMessages
		case offsetInFileOfOldestMessage
		case offsetInFileAtEndOfNewestMessage
		case reservedSpace

		var storageLength: Int {
			switch self {
			case .version:
				UInt8.storageLength
			case .maximumBytes:
				Bytes.storageLength
			case .overwriteOldMessages:
				Bool.storageLength
			case .offsetInFileOfOldestMessage:
				UInt64.storageLength
			case .offsetInFileAtEndOfNewestMessage:
				UInt64.storageLength
			case .reservedSpace:
				// Subtract from this value every time another additive field is added.
				// We currently have a total of 64 bytes reserved for the header.
				// We're currently using only 26 of them.
				38
			}
		}

		var rangeOfFieldInFile: Range<Int> {
			Int(expectedBeginningOfFieldInFile)..<Int(expectedEndOfFieldInFile)
		}

		var expectedBeginningOfFieldInFile: UInt64 {
			expectedEndOfFieldInFile - UInt64(storageLength)
		}

		var expectedEndOfFieldInFile: UInt64 {
			Field.allCases.dropLast(Field.allCases.count - rawValue).reduce(0) { totalOffset, currentField in
				totalOffset + UInt64(currentField.storageLength)
			}
		}
	}
}