import Foundation

public enum CaptureRecordingState: Equatable {
    public static func == (lhs: Self, rhs: Self) -> Bool {
        switch lhs {
        case .needsSetup:
            guard case .needsSetup = rhs else { return false }
            return true

        case .readyToRecord:
            guard case .readyToRecord = rhs else { return false }
            return true

        case .isFlaggedForPhotoCaptureOnNextDraw:
            guard case .isFlaggedForPhotoCaptureOnNextDraw = rhs else { return false }
            return true

        case .isRecording:
            guard case .isRecording = rhs else { return false }
            return true

        case .isFlaggedToCompleteRecordingOnNextDraw:
            guard case .isFlaggedToCompleteRecordingOnNextDraw = rhs else { return false }
            return true

        case .isEndingRecording:
            guard case .isEndingRecording = rhs else { return false }
            return true

        case .completed:
            guard case .completed = rhs else { return false }
            return true
        }
    }

    public func isValueEqual(_ other: Self) -> Bool {
        switch self {
        case .needsSetup,
             .readyToRecord,
             .isFlaggedForPhotoCaptureOnNextDraw,
             .isFlaggedToCompleteRecordingOnNextDraw,
             .isEndingRecording,
             .completed:
            return self == other
        case .isRecording(let selfElapsedTime, let selfFrameIndex):
            guard case .isRecording(let otherElapsedTime, let otherFrameIndex) = other else { return false }
            return selfElapsedTime == otherElapsedTime && selfFrameIndex == otherFrameIndex
        }
    }

    case needsSetup
    case readyToRecord

    case isFlaggedForPhotoCaptureOnNextDraw

    case isRecording(_ elapsedTime: TimeInterval, frameIndex: Int)
    case isFlaggedToCompleteRecordingOnNextDraw
    case isEndingRecording

    case completed
}