//
//  Buffer.swift
//  Git
//
//  Created by Erik Aigner on 02.10.18.
//  Copyright © 2018 bytieful. All rights reserved.
//
import Foundation


/// Buffer maintains a buffer without copy-on-write semantics.
public struct Buffer {
    
    private let ref: PointerRef
    private let range: Range<Int>
    
    public init(data: Data) {
        let storage = UnsafeMutableBufferPointer<UInt8>.allocate(capacity: data.count)
        let n = data.copyBytes(to: storage)
        
        assert(n == data.count)
        
        self.init(ref: PointerRef(storage), range: 0..<data.count)
    }
    
    private init(ref: PointerRef, range: Range<Int>) {
        self.range = range
        self.ref = ref
    }
    
    public var count: Int {
        return range.count
    }
    
    public subscript(_ i: Int) -> UInt8 {
        return ref.buf[range.startIndex + i]
    }
    
    /// Returns a slice.
    /// The new buffer slice start index is 0 and count is the range width.
    public subscript(_ range: Range<Int>) -> Buffer {
        let start = self.range.startIndex + range.startIndex
        let end = start + range.count
        return Buffer(ref: ref, range: start..<end)
    }
    
    public func data() -> Data {
        guard let baseAddress = ref.buf.baseAddress else {
            return Data()
        }
        return Data(bytes: baseAddress + range.startIndex, count: range.count)
    }
}


/// Used to automatically release a buffer pointer
/// if all referencing objects cease to exist.
private class PointerRef {
    
    let buf: UnsafeMutableBufferPointer<UInt8>
    
    init(_ buf: UnsafeMutableBufferPointer<UInt8>) {
        self.buf = buf
    }
    
    deinit {
        buf.deallocate()
    }
}