import Foundation

import UIKit
import XCTest

import Postbox
@testable import Postbox

import SwiftSignalKit

private let peerId = PeerId(namespace: 1, id: 1)
private let namespace: Int32 = 1

private extension MessageIndex {
    init(id: Int32, timestamp: Int32) {
        self.init(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp)
    }
}

private extension MessageTags {
    static let media = MessageTags(rawValue: 1 << 0)
}

class MessageHistoryIndexTableTests: XCTestCase {
    var valueBox: ValueBox?
    var path: String?
    
    var postbox: Postbox?
    
    override func setUp() {
        super.setUp()
        
        self.continueAfterFailure = false
        
        var randomId: Int64 = 0
        arc4random_buf(&randomId, 8)
        path = NSTemporaryDirectory() + "\(randomId)"
        self.valueBox = SqliteValueBox(basePath: path!, queue: Queue.mainQueue())
        
        let messageHoles: [PeerId.Namespace: [MessageId.Namespace: Set<MessageTags>]] = [
            peerId.namespace: [
                namespace: Set([.media])
            ]
        ]
        
        let seedConfiguration = SeedConfiguration(initializeChatListWithHole: (topLevel: nil, groups: nil), messageHoles: messageHoles, messageTagsWithSummary: [], existingGlobalMessageTags: [], peerNamespacesRequiringMessageTextIndex: [], peerSummaryCounterTags: { _ in PeerSummaryCounterTags(rawValue: 0) }, additionalChatListIndexNamespace: nil)
        
        self.postbox = Postbox(queue: Queue.mainQueue(), basePath: path!, globalMessageIdsNamespace: namespace, seedConfiguration: seedConfiguration, valueBox: self.valueBox!)
    }
    
    override func tearDown() {
        super.tearDown()
        
        self.postbox = nil
        let _ = try? FileManager.default.removeItem(atPath: path!)
        self.path = nil
    }
    
    func addHole(_ range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
        var operations: [MessageHistoryIndexHoleOperationKey: [MessageHistoryIndexHoleOperation]] = [:]
        self.postbox!.messageHistoryHoleIndexTable.add(peerId: peerId, namespace: namespace, space: space, range: range, operations: &operations)
    }
    
    func removeHole(_ range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
        var operations: [MessageHistoryIndexHoleOperationKey: [MessageHistoryIndexHoleOperation]] = [:]
        self.postbox!.messageHistoryHoleIndexTable.remove(peerId: peerId, namespace: namespace, space: space, range: range, operations: &operations)
    }
    
    func addMessage(_ id: Int32, _ timestamp: Int32, _ groupingKey: Int64? = nil) {
        var operations: [MessageHistoryIndexOperation] = []
        self.postbox!.messageHistoryIndexTable.addMessages([InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp, globallyUniqueId: nil, groupingKey: groupingKey, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])], operations: &operations)
    }
    
    func removeMessage(_ id: Int32) {
        var operations: [MessageHistoryIndexOperation] = []
        self.postbox!.messageHistoryIndexTable.removeMessage(MessageId(peerId: peerId, namespace: namespace, id: id), operations: &operations)
    }
    
    private func expectMessages(_ items: [MessageIndex]) {
        let actualList = self.postbox!.messageHistoryIndexTable.debugList(peerId, namespace: namespace)
        if items != actualList {
            XCTFail("Expected\n\(items)\nGot\n\(actualList)")
        }
    }
    
    private func expectHoles(space: MessageHistoryHoleSpace, _ ranges: [ClosedRange<Int32>], failure: () -> Void = {}) {
        let actualList = self.postbox!.messageHistoryHoleIndexTable.debugList(peerId: peerId, namespace: namespace, space: space)
        if ranges != actualList {
            failure()
            XCTFail("Expected\n\(ranges)\nGot\n\(actualList)")
        }
    }
    
    func testEmpty() {
        expectMessages([])
        expectHoles(space: .everywhere, [])
        expectHoles(space: .tag(.media), [])
    }
    
    func testSimpleMessages() {
        addMessage(10, 10)
        expectMessages([.init(id: 10, timestamp: 10)])
        addMessage(11, 11)
        expectMessages([.init(id: 10, timestamp: 10), .init(id: 11, timestamp: 11)])
        expectHoles(space: .everywhere, [])
        expectHoles(space: .tag(.media), [])
    }
    
    func testSimpleHoles() {
        addHole(3 ... 10, space: .everywhere)
        expectHoles(space: .everywhere, [3 ... 10])
        
        addHole(3 ... 10, space: .everywhere)
        expectHoles(space: .everywhere, [3 ... 10])
        
        addHole(5 ... 20, space: .everywhere)
        expectHoles(space: .everywhere, [3 ... 20])
        
        addHole(25 ... 30, space: .everywhere)
        expectHoles(space: .everywhere, [3 ... 20, 25 ... 30])
        
        addHole(21 ... 23, space: .everywhere)
        expectHoles(space: .everywhere, [3 ... 23, 25 ... 30])
        
        addHole(5 ... 25, space: .everywhere)
        expectHoles(space: .everywhere, [3 ... 30])
        
        addHole(2 ... 35, space: .everywhere)
        expectHoles(space: .everywhere, [2 ... 35])
        
        removeHole(1 ... 5, space: .everywhere)
        expectHoles(space: .everywhere, [6 ... 35])
        
        removeHole(11 ... 11, space: .everywhere)
        expectHoles(space: .everywhere, [6 ... 10, 12 ... 35])
        
        removeHole(8 ... 15, space: .everywhere)
        expectHoles(space: .everywhere, [6 ... 7, 16 ... 35])
        
        removeHole(1 ... 16, space: .everywhere)
        expectHoles(space: .everywhere, [17 ... 35])
    }
    
    func testHoleVectors() {
        struct Operation: Codable {
            struct Key: CodingKey {
                var stringValue: String
                
                init?(stringValue: String) {
                    self.stringValue = stringValue
                }
                
                let intValue: Int? = nil
                init?(intValue: Int) {
                    return nil
                }
            }
            
            let add: Bool
            let range: ClosedRange<Int32>
            
            init(add: Bool, range: ClosedRange<Int32>) {
                self.add = add
                self.range = range
            }
            
            init(from decoder: Decoder) throws {
                let container = try decoder.container(keyedBy: Key.self)
                self.add = try container.decode(Bool.self, forKey: Key(stringValue: "a")!)
                self.range = (try container.decode(Int32.self, forKey: Key(stringValue: "l")!)) ... (try container.decode(Int32.self, forKey: Key(stringValue: "u")!))
            }
            
            func encode(to encoder: Encoder) throws {
                var container = encoder.container(keyedBy: Key.self)
                try container.encode(self.add, forKey: Key(stringValue: "a")!)
                try container.encode(self.range.lowerBound, forKey: Key(stringValue: "l")!)
                try container.encode(self.range.upperBound, forKey: Key(stringValue: "u")!)
            }
        }
        
        let bundle = Bundle(for: type(of: self))
        let path = bundle.path(forResource: "HoleOperationsVector1", ofType: "json")!
        let jsonData = try! Data(contentsOf: URL(fileURLWithPath: path))
        
        var operations: [Operation] = (try? JSONDecoder().decode(Array<Operation>.self, from: jsonData)) ?? []
        
        if operations.isEmpty {
            for _ in 0 ..< 10000 {
                let bound1 = Int(max(1, arc4random_uniform(1000)))
                let bound2 = Int(max(1, arc4random_uniform(1000)))
                let range: ClosedRange<Int> = min(bound1, bound2) ... max(bound1, bound2)
                let int32Range = Int32(range.lowerBound) ... Int32(range.upperBound)
                let operation = arc4random_uniform(10)
                if operation < 5 {
                    operations.append(Operation(add: true, range: int32Range))
                } else {
                    operations.append(Operation(add: false, range: int32Range))
                }
            }
            let data = try! JSONEncoder().encode(operations)
            print(String(data: data, encoding: .utf8)!)
        }
        
        var verificationSet = IndexSet()
        for i in 0 ..< operations.count {
            let operation = operations[i]
            if operation.add {
                verificationSet.insert(integersIn: Int(operation.range.lowerBound) ... Int(operation.range.upperBound))
                addHole(operation.range, space: .everywhere)
            } else {
                verificationSet.remove(integersIn: Int(operation.range.lowerBound) ... Int(operation.range.upperBound))
                removeHole(operation.range, space: .everywhere)
            }
            let testRanges = verificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ..< Int32($0.upperBound)) })
            expectHoles(space: .everywhere, testRanges)
            expectHoles(space: .tag(.media), testRanges)
        }
    }
    
    func testHoleTagVectors() {
        struct Operation: Codable {
            struct Key: CodingKey {
                var stringValue: String
                
                init?(stringValue: String) {
                    self.stringValue = stringValue
                }
                
                let intValue: Int? = nil
                init?(intValue: Int) {
                    return nil
                }
            }
            
            let add: Bool
            let range: ClosedRange<Int32>
            let space: MessageHistoryHoleSpace
            
            init(add: Bool, range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
                self.add = add
                self.range = range
                self.space = space
            }
            
            init(from decoder: Decoder) throws {
                let container = try decoder.container(keyedBy: Key.self)
                self.add = try container.decode(Bool.self, forKey: Key(stringValue: "a")!)
                self.range = (try container.decode(Int32.self, forKey: Key(stringValue: "l")!)) ... (try container.decode(Int32.self, forKey: Key(stringValue: "u")!))
                let spaceValue = try container.decode(Int32.self, forKey: Key(stringValue: "s")!)
                if spaceValue == 0 {
                    self.space = .everywhere
                } else {
                    self.space = .tag(MessageTags(rawValue: UInt32(spaceValue)))
                }
            }
            
            func encode(to encoder: Encoder) throws {
                var container = encoder.container(keyedBy: Key.self)
                try container.encode(self.add, forKey: Key(stringValue: "a")!)
                try container.encode(self.range.lowerBound, forKey: Key(stringValue: "l")!)
                try container.encode(self.range.upperBound, forKey: Key(stringValue: "u")!)
                switch self.space {
                    case .everywhere:
                        try container.encode(0, forKey: Key(stringValue: "s")!)
                    case let .tag(tag):
                        try container.encode(Int32(tag.rawValue), forKey: Key(stringValue: "s")!)
                }
            }
        }
        
        var operations: [Operation] = []
        let bundle = Bundle(for: type(of: self))
        if let path = bundle.path(forResource: "HoleOperationsVector2", ofType: "json"), let jsonData = try? Data(contentsOf: URL(fileURLWithPath: path)) {
            if let value = try? JSONDecoder().decode(Array<Operation>.self, from: jsonData) {
                operations = value
            }
        }
        
        if operations.isEmpty {
            for _ in 0 ..< 10000 {
                let bound1 = Int(max(1, arc4random_uniform(1000)))
                let bound2 = Int(max(1, arc4random_uniform(1000)))
                let range: ClosedRange<Int> = min(bound1, bound2) ... max(bound1, bound2)
                let int32Range = Int32(range.lowerBound) ... Int32(range.upperBound)
                let operation = arc4random_uniform(10)
                let spaceValue = arc4random_uniform(2)
                let space: MessageHistoryHoleSpace
                if spaceValue == 0 {
                    space = .everywhere
                } else {
                    space = .tag(.media)
                }
                if operation < 5 {
                    operations.append(Operation(add: true, range: int32Range, space: space))
                } else {
                    operations.append(Operation(add: false, range: int32Range, space: space))
                }
            }
            let data = try! JSONEncoder().encode(operations)
            print(String(data: data, encoding: .utf8)!)
        }
        
        var everywhereVerificationSet = IndexSet()
        var mediaVerificationSet = IndexSet()
        for i in 0 ..< operations.count {
            let operation = operations[i]
            let intRange = Int(operation.range.lowerBound) ... Int(operation.range.upperBound)
            if operation.add {
                switch operation.space {
                    case .everywhere:
                        everywhereVerificationSet.insert(integersIn: intRange)
                        mediaVerificationSet.insert(integersIn: intRange)
                    case .tag:
                        mediaVerificationSet.insert(integersIn: intRange)
                }
                addHole(operation.range, space: operation.space)
            } else {
                switch operation.space {
                    case .everywhere:
                        everywhereVerificationSet.remove(integersIn: intRange)
                        mediaVerificationSet.remove(integersIn: intRange)
                    case .tag:
                        mediaVerificationSet.remove(integersIn: intRange)
                }
                removeHole(operation.range, space: operation.space)
            }
            let everywhereTestRanges = everywhereVerificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ..< Int32($0.upperBound)) })
            let mediaTestRanges = mediaVerificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ..< Int32($0.upperBound)) })
            expectHoles(space: .everywhere, everywhereTestRanges)
            expectHoles(space: .tag(.media), mediaTestRanges)
        }
    }
    
    /*func addMessagesUpperBlock(_ messages: [(Int32, Int32)]) {
        var operations: [MessageHistoryIndexOperation] = []
        self.indexTable!.addMessages(messages.map { (id, timestamp) in
            return InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp, globallyUniqueId: nil, groupingKey: nil, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])
        }, location: .UpperHistoryBlock, operations: &operations)
    }
    
    func fillHole(_ id: Int32, _ fillType: HoleFill, _ messages: [(Int32, Int32, Int64?)], _ tagMask: MessageTags? = nil) {
        var operations: [MessageHistoryIndexOperation] = []
        
        self.indexTable!.fillHole(MessageId(peerId: peerId, namespace: namespace, id: id), fillType: fillType, tagMask: tagMask, messages: messages.map({
            return InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: $0.0), timestamp: $0.1, globallyUniqueId: nil, groupingKey: $0.2, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])
        }), operations: &operations)
    }
    
    func fillMultipleHoles(_ mainId: Int32, _ fillType: HoleFill, _ messages: [(Int32, Int32)], _ tagMask: MessageTags? = nil) {
        var operations: [MessageHistoryIndexOperation] = []
        self.indexTable!.fillMultipleHoles(mainHoleId: MessageId(peerId: peerId, namespace: namespace, id: mainId), fillType: fillType, tagMask: tagMask, messages: messages.map({
            return InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: $0.0), timestamp: $0.1, globallyUniqueId: nil, groupingKey: nil, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])
        }), operations: &operations)
    }
    
    private func expect(_ items: [Item]) {
        let actualList = self.indexTable!.debugList(peerId, namespace: namespace)
        let actualItems = actualList.map { return Item($0) }
        if items != actualItems {
            XCTFail("Expected\n\(items)\nGot\n\(actualItems)")
        }
    }
    
    func testEmpty() {
        expect([])
    }
    
    func testAddMessageToEmpty() {
        addMessage(100, 100)
        expect([.Message(100, 100)])
        
        addMessage(110, 110)
        expect([.Message(100, 100), .Message(110, 110)])
        
        addMessage(90, 90)
        expect([.Message(90, 90), .Message(100, 100), .Message(110, 110)])
    }
    
    func testAddMessageIgnoreOverwrite() {
        addMessage(100, 100)
        expect([.Message(100, 100)])
        
        addMessage(100, 110)
        expect([.Message(100, 100)])
    }
    
    func testAddHoleToEmpty() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
    }
    
    func testAddHoleToFullHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        addHole(110)
        expect([.Hole(1, Int32.max, Int32.max)])
    }
    
    func testAddMessageToFullHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        addMessage(90, 90)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
    }
    
    func testAddMessageDividingUpperHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        addMessage(90, 90)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
        addMessage(100, 100)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, 99, 100), .Message(100, 100), .Hole(101, Int32.max, Int32.max)])
    }
    
    func testAddMessageDividingLowerHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        addMessage(90, 90)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
        addMessage(80, 80)
        expect([.Hole(1, 79, 80), .Message(80, 80), .Hole(81, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
    }
    
    func testAddMessageOffsettingUpperHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        
        addMessage(90, 90)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
        addMessage(91, 91)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Message(91, 91), .Hole(92, Int32.max, Int32.max)])
    }
    
    func testAddMessageOffsettingLowerHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        
        addMessage(90, 90)
        expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
        addMessage(89, 89)
        expect([.Hole(1, 88, 89), .Message(89, 89), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
    }
    
    func testAddMessageOffsettingLeftmostHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        
        addMessage(1, 1)
        
        expect([.Message(1, 1), .Hole(2, Int32.max, Int32.max)])
    }
    
    func testAddMessageRemovingLefmostHole() {
        addHole(100)
        expect([.Hole(1, Int32.max, Int32.max)])
        
        addMessage(2, 2)
        expect([.Hole(1, 1, 2), .Message(2, 2), .Hole(3, Int32.max, Int32.max)])
        
        addMessage(1, 1)
        expect([.Message(1, 1), .Message(2, 2), .Hole(3, Int32.max, Int32.max)])
    }
    
    func testAddHoleLowerThanMessage() {
        addMessage(100, 100)
        addHole(1)
        
        expect([.Hole(1, 99, 100), .Message(100, 100)])
    }
    
    func testAddHoleHigherThanMessage() {
        addMessage(100, 100)
        addHole(200)
        
        expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
    }
    
    func testIgnoreHigherHole() {
        addHole(200)
        expect([.Hole(1, Int32.max, Int32.max)])
        addHole(400)
        expect([.Hole(1, Int32.max, Int32.max)])
    }
    
    func testIgnoreHigherHoleAfterMessage() {
        addMessage(100, 100)
        addHole(200)
        expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
        addHole(400)
        expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
    }
    
    func testAddHoleBetweenMessages() {
        addMessage(100, 100)
        addMessage(200, 200)
        addHole(150)
        
        expect([.Message(100, 100), .Hole(101, 199, 200), .Message(200, 200)])
    }
    
    func testFillHoleEmpty() {
        fillHole(1, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [])
        expect([])
    }

    func testFillHoleComplete() {
        addHole(100)
        
        fillHole(1, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(100, 100, nil), (200, 200, nil)])
        expect([.Message(100, 100), .Message(200, 200)])
    }
    
    func testFillHoleUpperToLowerPartial() {
        addHole(100)
        
        fillHole(1, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(100, 100, nil), (200, 200, nil)])
        expect([.Hole(1, 99, 100), .Message(100, 100), .Message(200, 200)])
    }
    
    func testFillHoleUpperToLowerToBounds() {
        addHole(100)
        
        fillHole(1, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(1, 1, nil), (200, 200, nil)])
        expect([.Message(1, 1), .Message(200, 200)])
    }
    
    func testFillHoleLowerToUpperToBounds() {
        addHole(100)
        
        fillHole(1, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(100, 100, nil), (Int32.max, 200, nil)])
        expect([.Message(100, 100), .Message(Int32.max, 200)])
    }
    
    func testFillHoleLowerToUpperPartial() {
        addHole(100)
        
        fillHole(1, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(100, 100, nil), (200, 200, nil)])
        expect([.Message(100, 100), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
    }
    
    func testFillHoleBetweenMessagesUpperToLower() {
        addHole(1)
        
        addMessage(100, 100)
        addMessage(200, 200)
        
        fillHole(199, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(150, 150, nil)])
        
        expect([.Hole(1, 99, 100), .Message(100, 100), .Hole(101, 149, 150), .Message(150, 150), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
    }
    
    func testFillHoleBetweenMessagesLowerToUpper() {
        addHole(1)
        
        addMessage(100, 100)
        addMessage(200, 200)
        
        fillHole(199, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(150, 150, nil)])
        
        expect([.Hole(1, 99, 100), .Message(100, 100), .Message(150, 150), .Hole(151, 199, 200), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
    }
    
    func testFillHoleBetweenMessagesComplete() {
        addHole(1)
        
        addMessage(100, 100)
        addMessage(200, 200)
        
        fillHole(199, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(150, 150, nil)])
        
        expect([.Hole(1, 99, 100), .Message(100, 100), .Message(150, 150), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
    }
    
    func testFillHoleBetweenMessagesWithMessage() {
        addMessage(200, 200)
        addMessage(202, 202)
        addHole(201)
        addMessage(201, 201)
        
        expect([.Message(200, 200), .Message(201, 201), .Message(202, 202)])
    }
    
    func testFillHoleWithNoMessagesComplete() {
        addMessage(100, 100)
        addHole(1)
        
        fillHole(99, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [])
        
        expect([.Message(100, 100)])
    }
    
    func testFillHoleIgnoreOverMessage() {
        addMessage(100, 100)
        addMessage(101, 101)
        
        fillHole(100, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(90, 90, nil)])
        
        expect([.Message(90, 90), .Message(100, 100), .Message(101, 101)])
    }
    
    func testFillHoleWithOverflow() {
        addMessage(100, 100)
        addMessage(200, 200)
        addHole(150)
        
        fillHole(199, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(150, 150, nil), (300, 300, nil)])
        
        expect([.Message(100, 100), .Hole(101, 149, 150), .Message(150, 150), .Message(200, 200), .Message(300, 300)])
    }
    
    func testIgnoreHoleOverMessageBetweenMessages() {
        addMessage(199, 199)
        addMessage(200, 200)
        addHole(200)
        
        expect([.Message(199, 199), .Message(200, 200)])
    }
    
    func testMergeHoleAfterDeletingMessage() {
        addMessage(100, 100)
        addHole(1)
        addHole(200)
        
        expect([.Hole(1, 99, 100), .Message(100, 100), .Hole(101, Int32.max, Int32.max)])
        
        removeMessage(100)
        
        expect([.Hole(1, Int32.max, Int32.max)])
    }
    
    func testMergeHoleLowerAfterDeletingMessage() {
        addMessage(100, 100)
        addHole(1)
        addMessage(200, 200)
        
        removeMessage(100)
        
        expect([.Hole(1, 199, 200), .Message(200, 200)])
    }
    
    func testMergeHoleUpperAfterDeletingMessage() {
        addMessage(100, 100)
        addMessage(200, 200)
        addHole(300)
        
        removeMessage(200)
        
        expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
    }
    
    func testExtendLowerHoleAfterDeletingMessage() {
        addMessage(100, 100)
        addHole(100)
        
        removeMessage(100)
        
        expect([.Hole(1, Int32.max, Int32.max)])
    }
    
    func testExtendUpperHoleAfterDeletingMessage() {
        addMessage(100, 100)
        addHole(101)
        
        removeMessage(100)
        
        expect([.Hole(1, Int32.max, Int32.max)])
    }
    
    func testDeleteMessageBelowMessage() {
        addMessage(100, 100)
        addMessage(200, 200)
        removeMessage(100)
        
        expect([.Message(200, 200)])
    }
    
    func testDeleteMessageAboveMessage() {
        addMessage(100, 100)
        addMessage(200, 200)
        removeMessage(200)
        
        expect([.Message(100, 100)])
    }
    
    func testDeleteMessageBetweenMessages() {
        addMessage(100, 100)
        addMessage(200, 200)
        addMessage(300, 300)
        removeMessage(200)
        
        expect([.Message(100, 100), .Message(300, 300)])
    }
    
    func testAddMessageCutInitialHole() {
        addHole(1)
        expect([.Hole(1, Int32.max, Int32.max)])
        addMessagesUpperBlock([(100, 100)])
        expect([.Hole(1, 99, 100), .Message(100, 100)])
    }
    
    func testAddMessageRemoveInitialHole() {
        addHole(1)
        expect([.Hole(1, Int32.max, Int32.max)])
        addMessagesUpperBlock([(1, 100)])
        expect([.Message(1, 100)])
    }
    
    func testAddMessageCutHoleAfterMessage1() {
        addMessage(10, 10)
        addHole(11)
        expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        addMessagesUpperBlock([(100, 100)])
        expect([.Message(10, 10), .Hole(11, 99, 100), .Message(100, 100)])
    }
    
    func testAddMessageCutHoleAfterMessage2() {
        addMessage(10, 10)
        addHole(11)
        expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        addMessagesUpperBlock([(12, 12)])
        expect([.Message(10, 10), .Hole(11, 11, 12), .Message(12, 12)])
    }
    
    func testAddMessageRemoveHoleAfterMessage() {
        addMessage(10, 10)
        addHole(11)
        expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        addMessagesUpperBlock([(11, 11)])
        expect([.Message(10, 10), .Message(11, 11)])
    }
    
    func testAddMessageRemoveHoleIgnoreOverwriteMessage() {
        addMessage(10, 10)
        addHole(11)
        expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        addMessagesUpperBlock([(10, 11)])
        expect([.Message(10, 10)])
    }
    
    func testFillHoleAtIndex() {
        addHole(1)
        expect([.Hole(1, Int32.max, Int32.max)])
        fillHole(1, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 10), lowerComplete: false, upperComplete: false)), [(5, 5, nil), (10, 10, nil)])
        expect([.Hole(1, 4, 5), .Message(5, 5), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
    }
    
    func testFillHoleAtIndexComplete() {
        addHole(1)
        expect([.Hole(1, Int32.max, Int32.max)])
        fillHole(1, HoleFill(complete: true, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 10), lowerComplete: false, upperComplete: false)), [(5, 5, nil), (10, 10, nil)])
        expect([.Message(5, 5), .Message(10, 10)])
    }
    
    func testFillMultipleHolesSingleHole() {
        addHole(1)
        expect([.Hole(1, Int32.max, Int32.max)])
        
        fillMultipleHoles(1, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(5, 5), (10, 10)])
        expect([.Hole(1, 4, 5), .Message(5, 5), .Message(10, 10)])
    }
    
    func testFillMultipleHolesTwoHolesUpperToLowerNotComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
    }
    
    func testFillMultipleHolesTwoHolesUpperToLowerNotCompleteSkipOverOne() {
        addHole(1)
        addMessage(10, 10)
        addMessage(13, 13)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, 12, 13), .Message(13, 13), .Hole(14, Int32.max, Int32.max)])
        
        fillMultipleHoles(20, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(13, 13), .Message(15, 15), .Message(20, 20)])
    }
    
    func testFillMultipleHolesTwoHolesUpperToLowerComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
    }
    
    func testFillMultipleHolesTwoHolesLowerToUpperNotComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
    }
    
    func testFillMultipleHolesTwoHolesLowerToUpperComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: true, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
    }
    
    func testFillMultipleHolesTwoHolesAroundIndexNotComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: false, upperComplete: false)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
    }
    
    func testFillMultipleHolesTwoHolesAroundIndexUpperComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: false, upperComplete: true)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
    }
    
    func testFillMultipleHolesTwoHolesAroundIndexLowerComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: true, upperComplete: false)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
    }
    
    func testFillMultipleHolesTwoHolesAroundIndexAutoComplete() {
        addHole(1)
        addMessage(10, 10)
        expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
        
        fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: false, upperComplete: false)), [(8, 8), (15, 15), (20, 20)])
        
        expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
    }
    
    func testHole1() {
        addMessage(1000, 1000)
        addMessage(1001, 1001)
        addHole(Int32.max)
        expect([.Message(1000, 1000), .Message(1001, 1001), .Hole(1002, Int32.max, Int32.max)])
        addMessagesUpperBlock([(1005, 1005)])
        expect([.Message(1000, 1000), .Message(1001, 1001), .Hole(1002, 1004, 1005), .Message(1005, 1005)])
        addMessage(1003, 1003)
        expect([.Message(1000, 1000), .Message(1001, 1001), .Hole(1002, 1002, 1003), .Message(1003, 1003), .Hole(1004, 1004, 1005), .Message(1005, 1005)])
    }*/
}