import CocoaLumberjackSwift
import Foundation

enum ChunkCacheError: Error {
    case invalidSequenceNumber
    case timeTravelForewards
    case timeTravelBackwards
}

final class WebChunkCache: NSObject {
    
    private var _sequenceNumber: WebSequenceNumber
    private var _byteLength = 0
    private var cache = [[UInt8]?]()
    
    init(sequenceNumber: WebSequenceNumber) {
        self._sequenceNumber = sequenceNumber
    }
    
    func sequenceNumber() -> WebSequenceNumber {
        _sequenceNumber
    }
    
    func byteLength() -> Int {
        _byteLength
    }
    
    func chunks() -> [[UInt8]?] {
        cache
    }
    
    func transfer(fromCache: [[UInt8]?]) {
        DDLogVerbose("[Threema Web] Web Chunk Cache --> start transfer cache")
        let tmpCache = cache.compactMap(\.self)
        cache = tmpCache
        for chunk in fromCache {
            if chunk != nil {
                append(chunk: chunk)
            }
        }
        DDLogVerbose("[Threema Web] Web Chunk Cache --> end transfer cache")
    }
    
    func append(chunk: [UInt8]?) {
        if chunk != nil {
            _byteLength = _byteLength + chunk!.count
        }
        cache.append(chunk)
        _ = _sequenceNumber.increment()
        DDLogVerbose("[Threema Web] Web Chunk Cache --> \(_sequenceNumber.value)")
    }
    
    func prune(theirSequenceNumber: UInt32) throws {
        if sequenceNumber().isValid(other: UInt64(theirSequenceNumber)) == false {
            // error: Remote sent us an invalid sequence number
            throw ChunkCacheError.invalidSequenceNumber
        }
        
        // Calculate the slice start index for the chunk cache
        // Important: Our sequence number is one chunk ahead!
        
        let offset = Int64(theirSequenceNumber) - Int64(_sequenceNumber.value)
        if offset > 0 {
            // error: Remote travelled through time and acknowledged a chunk which is in the future
            DDLogNotice(
                "[Threema Web] Prune Cache Error timeTravelForewards --> their: \(Int64(theirSequenceNumber)) my: \(Int64(_sequenceNumber.value))"
            )
            throw ChunkCacheError.timeTravelForewards
        }
        else if -offset > cache.count {
            // error: Remote travelled back in time and acknowledged a chunk it has already acknowledged
            DDLogNotice(
                "[Threema Web] Prune Cache Error timeTravelBackwards --> their: \(Int64(theirSequenceNumber)) my: \(Int64(cache.count))"
            )
            throw ChunkCacheError.timeTravelBackwards
        }
        DDLogNotice(
            "[Threema Web] Prune Cache --> their: \(Int64(theirSequenceNumber)) my: \(Int64(_sequenceNumber.value))"
        )
        
        let endOffset = Int(Int64(cache.count) + offset)
        
        if endOffset == cache.count {
            cache = [[UInt8]]()
            _byteLength = 0
        }
        else {
            let removedChunks = cache[..<endOffset]
            let tmpCache = cache
            cache = Array(tmpCache.dropFirst(endOffset))
            for chunk in removedChunks {
                if chunk != nil {
                    _byteLength = _byteLength - chunk!.count
                }
            }
        }
    }
}