import os, sys, time

print(os.getcwd())
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
FILE_DIR = os.path.join(BASE_DIR, 'my_file.txt')
OUT_DIR = os.path.join(BASE_DIR, 'out.txt')
REC_DIR = os.path.join(BASE_DIR, 'rec.txt')

python3 = sys.version_info.major >= 3

content1 = 1000 * '012345666666666666666666789999999999'
content2 = 1000 * '0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 8 9 9 9 9 9 9 9 9 9 9'
content3 = 1000 * '0,1,2,3,4,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,8,9,9,9,9,9,9,9,9,9,9'

f = open(FILE_DIR, 'wt')
f.write(content1)
f.close()

t_start = time.time()
os.system('python arithmetic-compress.py {InputFile} {OutputFile}'.format(InputFile=FILE_DIR, OutputFile=OUT_DIR))
os.system('python arithmetic-decompress.py {InputFile} {OutputFile}'.format(InputFile=OUT_DIR, OutputFile=REC_DIR))
t_end = time.time() - t_start
rate_ori = os.path.getsize(FILE_DIR)  # file size in bytes
rate_out = os.path.getsize(OUT_DIR)
rate_rec = os.path.getsize(REC_DIR)
os.remove(OUT_DIR)  # remove a file
os.remove(REC_DIR)

#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include "ArithmeticCoder.hpp"
#include "BitIoStream.hpp"
#include "FrequencyTable.hpp"
using namespace std;

static int compressPrecomputeFrequencyTable(vector<int>& in, BitOutputStream &bOut)
{

    SimpleFrequencyTable freqs(std::vector<uint32_t>(257, 0));
    freqs.increment(256);  // EOF symbol gets a frequency of 1
    for (unsigned int i=0; i < in.size(); i++) {
        int b = in[i];
        if (b < 0 || b > 255)
            throw std::logic_error("Assertion error");
        freqs.increment(static_cast<uint32_t>(b));
    }

    try {

        // Write frequency table
        for (uint32_t i = 0; i < 256; i++) {
            uint32_t freq = freqs.get(i);
            for (int j = 31; j >= 0; j--)
                bOut.write(static_cast<int>((freq >> j) & 1));  // Big endian
        }

        ArithmeticEncoder enc(32, bOut);
        for (unsigned int i=0; i < in.size(); i++) {
            // Read and encode one byte
            int symbol = in[i];
            if (symbol < 0 || symbol > 255)
                throw std::logic_error("Assertion error");
            enc.write(freqs, static_cast<uint32_t>(symbol));
        }

        enc.write(freqs, 256);  // EOF
        enc.finish(); // Flush remaining code bits

        return EXIT_SUCCESS;

    } catch (const char *msg) {
        std::cerr << msg << std::endl;
        return EXIT_FAILURE;
    }
}

static int decompressPrecomputeFrequencyTable(BitInputStream &bIn, vector<int> &out)
{
    // Perform file decompression

    try {

        // Read frequency table
        SimpleFrequencyTable freqs(std::vector<uint32_t>(257, 0));
        for (uint32_t i = 0; i < 256; i++) {
            uint32_t freq = 0;
            for (int j = 0; j < 32; j++)
                freq = (freq << 1) | bIn.readNoEof();  // Big endian
            freqs.set(i, freq);
        }
        freqs.increment(256);  // EOF symbol

        ArithmeticDecoder dec(32, bIn);
        while (true) {
            uint32_t symbol = dec.read(freqs);
            if (symbol == 256)  // EOF symbol
                break;
            int b = static_cast<int>(symbol);

            out.push_back(b);
        }
        return EXIT_SUCCESS;

    } catch (const char *msg) {
        std::cerr << msg << std::endl;
        return EXIT_FAILURE;
    }

}

int main()
{
    vector<int> encodingStream1 = {0, 0, 1, 1, 1, 2, 2, 254, 254, 255, 255, 10, 10};
    vector<int> encodingStream2 = {1,0,1};

    {
        int ok;
        std::ofstream out("enc.bin", std::ios::binary);
        BitOutputStream bOut(out);

        ok = compressPrecomputeFrequencyTable(encodingStream1, bOut);
        if(ok ==EXIT_FAILURE)
        {
            cerr << "can not compress stream 1" << endl;
            return 0;
        }
        ok = compressPrecomputeFrequencyTable(encodingStream2, bOut);
        if(ok ==EXIT_FAILURE)
        {
            cerr << "can not compress stream 2" << endl;
            return 0;
        }

        bOut.finish();


    }
    vector<int> decodedStream1;
    vector<int> decodedStream2;
    {

        int ok;
        std::ifstream in("enc.bin", std::ios::binary);
        BitInputStream bIn(in);

        ok =decompressPrecomputeFrequencyTable(bIn, decodedStream1);
        if(ok ==EXIT_FAILURE)
        {
            cerr << "can not decompress stream 1" << endl;
            return 0;
        }
        ok = decompressPrecomputeFrequencyTable(bIn, decodedStream2);
        if(ok ==EXIT_FAILURE)
        {
            cerr << "can not decompress stream 2" << endl;
            return 0;
        }

    }


    if(decodedStream1.size() != encodingStream1.size())
    {
        cerr << "Error in decoding. size do not matches in the first stream" << endl;
        return -1;
    }

    for(unsigned int i=0; i < decodedStream1.size(); i++)
    {
        if(decodedStream1[i] != encodingStream1[i])
        {
            cerr << "decoded symbol is not equal to encoded symbol for the first stream" << endl;
            return -1;
        }
    }

    if(decodedStream2.size() != encodingStream2.size())
    {
        cerr << "Error in decoding. size do not matches in the second stream" << endl;
        return -1;
    }

    for(unsigned int i=0; i < decodedStream2.size(); i++)
    {
        if(decodedStream2[i] != encodingStream2[i])
        {
            cerr << "decoded symbol is not equal to encoded symbol for the second stream" << endl;
            return -1;
        }
    }

    cout << "successfully decoded" << endl;

    return 0;
}

(let [input "Hello World! Hello World! "
      baos-c (java.io.ByteArrayOutputStream.)
      charset "UTF-8"]
  (io.nayuki.PpmCompress/compress
    (-> input
        (.getBytes charset)
        (java.io.ByteArrayInputStream.))
    baos-c)
  (let [compressed (.toByteArray baos-c)
        _ (println (count compressed))
        intermediate (java.io.ByteArrayInputStream. compressed)
        baos-d (java.io.ByteArrayOutputStream.)]
    (println "before")
    (io.nayuki.PpmDecompress/decompress intermediate baos-d)
    (println "after")
    (String. (.toByteArray baos-d))))

class ArithmeticEncoder(ArithmeticCoderBase):
    def finish(self):
        self.output.write(1)

    def finish(self):
        self.output.write(1)
        self.output.close()

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class DummyClass {
    public static void main(String[] args) throws IOException {
        List<byte[]> list = new ArrayList();

        ByteBuffer byteBuffer = ByteBuffer.allocate(3);
        byteBuffer.put((byte)'a');
        byteBuffer.put((byte)'b');
        byteBuffer.put((byte)'c');

        //COMPRESS

        OutputStream os = new ByteArrayOutputStream();
        InputStream in = new ByteArrayInputStream(byteBuffer.array());
        BitOutputStream out = new BitOutputStream(os);

        //======================================================================================
        //AdaptiveHuffmanCompress.compress(in,out); <---- THIS WORKS
        AdaptiveArithmeticCompress.compress(in, out);
        //======================================================================================

        list.add(((ByteArrayOutputStream) os).toByteArray());

        //DECOMPRESS

        BitInputStream in2 = new BitInputStream(new ByteArrayInputStream(list.get(0)));
        OutputStream out2 = new ByteArrayOutputStream();

        //======================================================================================
//        try{
//            AdaptiveHuffmanDecompress.decompress(in2, out2); <---- THIS WORKS
//        }
//        catch (EOFException ex){
//            //IDK why is this happening but it doesn't affect the funcionality
//        }
        AdaptiveArithmeticDecompress.decompress(in2, out2);
        //======================================================================================

        ByteBuffer output = ByteBuffer.wrap(((ByteArrayOutputStream) out2).toByteArray());

        for (int i = 0; i < output.capacity(); i++){
            System.out.println((char)output.get());
        }
    }
}