using Invercargill.DataStructures;

namespace Invercargill {

    public interface BinaryData : Enumerable<uint8> {

        public virtual string to_raw_string(bool null_terminate = true) {
            Enumerable<uint8> data = this;
            if(null_terminate) {
                data.concat(Invercargill.single<uint8>(0));
            }
            return (string)data.to_array();
        }

        public virtual string to_base64() {
            return Base64.encode(to_array());
        }

        public virtual string to_hex() {
            return to_string(i => i.to_string("%x"));
        }

        public virtual Bytes to_bytes() {
            return new Bytes(to_array());
        }

        public virtual ByteBuffer to_byte_buffer() {
            return new ByteBuffer.from_enumerable(this);
        }

        public virtual BinaryData slice(int start, int end) {
            return skip(start).take(end-start).assert_promotion<BinaryData>();
        }

        public virtual ByteBuffer read(int start, int length) {
            return new ByteBuffer.from_enumerable(skip(start).take(length));
        }

        public virtual size_t write_to(void* array, size_t max_size) {
            var data = to_array();
            var size = max_size > data.length ? data.length : max_size;
            Memory.copy(array, data, size);
            return size;
        }
        
    }

}