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
}