#include <iostream>
#include <assert.h>
#include <memory>
#include <fstream>
#include "TrackingDeque.h"
#include <unistd.h>
#include <sys/types.h>
#include <cstring>
#include <stdio.h>
#include <ctype.h>
using namespace std;

class BufferedFile : public fstream
{
  public:
    void get(char &ch);
    void put(char ch);
    BufferedFile() = delete;
    BufferedFile(const BufferedFile &) = delete;
    BufferedFile(const string &name);
    int buffersize() { return buffer.size(); }
    void flushy();
    //bool eof() const;
    ios::streampos putpos;
    string filename;

  private:
    bool internal_eof;
    TrackingDeque<char> buffer;
    ios::streampos getpos;
};

BufferedFile::BufferedFile(const string &name)
    : internal_eof(false), getpos(0), putpos(0),
      fstream(name, ios::in | ios::out), filename(name)
{
}

void BufferedFile::get(char &ch)
{
    ch = '#';
    if (buffer.size() > 0)
    {
        cerr << "getting from buffer!\n";
        ch = buffer.front();
        buffer.pop_front();
    }
    else
    {
        seekg(getpos);
        if (fstream::eof())
            cerr << "eof  before fstream::get\n";
        fstream::get(ch); //trigger eof at some point
        if (fstream::eof())
        {
            cerr << "eof after fstream::get\n";
            internal_eof = true;
        }
        //getpos=tellg();
        getpos += 1;
    }
}

void BufferedFile::put(char ch)
{
    cerr << "BEFORE putpos=" << putpos << ", getpos=" << getpos << endl;
    assert(eof() || putpos <= getpos);
    if (putpos == getpos && !internal_eof)
    {
        char temp;
        seekg(getpos);
        fstream::get(temp);
        cerr << "temp: " << temp << "\n";
        getpos = tellg();
        cerr << "pushing back=>" << temp << "<=\n";
        buffer.push_back(temp);
    }
    cerr << "PUT CH: " << ch << " PUTPOS: " << putpos << "\n";
    seekg(putpos);
    fstream::put(ch);
    if (fstream::good())
        putpos = tellp();
    cerr << "AFTER putpos=" << putpos << ", getpos=" << getpos << endl
         << endl;
}
void BufferedFile::flushy()
{
    //fstream::clear();
    while (buffer.size() > 0)
    {
        fstream::clear();
        cerr << "buf size: " << buffer.size() << "\n";
        cerr << "FLUSHY! putpos=" << putpos << " buffer front=" << buffer.front() << "\n";
        //put('g');
        if (isalnum(buffer.front()))
        {
            fstream::put(buffer.front());
        } else {
            cerr << "skipping bad char >" << buffer.front() << "< \n";
        }
            buffer.pop_front();
    }
}

bool compare_match() {

}

int main(int argc, char *argv[])
{
    //BufferedFile bf;//do this, not smart pointers
    BufferedFile bf(argv[3]);
    string filename = argv[3];
    ifstream is;
    is.open(filename.c_str(), ios::binary);
    is.seekg(0, ios::end);
    int length = is.tellg();
    int cur_len = 0;
    cout << length << endl;

    enum State
    {
        SEARCHING,
        POTENTIAL_MATCH,
        FAILED_MATCH,
        SUCCESSFUL_MATCH
    };

    State state = SEARCHING;

    const char *srch = argv[1];
    int srch_len = std::strlen(srch);
    const char *repl = argv[2];
    int repl_len = std::strlen(repl);

    //while(!bf.eof())
    while (cur_len < length - (repl_len - srch_len))
    {
        cerr << cur_len << " until : " << length - (repl_len - srch_len) << endl;
        cout << "current_state=" << state << endl;
        char mychar;
        int num_matches = 0;
        int counter = 0;
        bf.get(mychar);
        cerr << "mychar=---------------------------->" << mychar << endl;
        if (mychar == srch[0])
        {
            state = POTENTIAL_MATCH;
            num_matches = 0;
            while (counter < srch_len && srch[num_matches] == mychar)
            {
                cerr << "srch[num_matche]: " << srch[num_matches] << "\n";
                cerr << "bf.get() mychar: " << mychar << "\n";
                ++counter;
                ++num_matches;
                if (counter < srch_len) {
                    bf.get(mychar);
                    cerr << "GET GET\n";
                }
            }
            cerr << "counter=" << counter << endl;
            if (counter < srch_len)
                state = FAILED_MATCH;
            else
                state = SUCCESSFUL_MATCH;
        }

        switch (state)
        {
        case SEARCHING:
            bf.put(mychar);
            break;
        case SUCCESSFUL_MATCH:
            for (int i = 0; i < repl_len; ++i) {
                cerr << "bf.put() char: " << repl[i] << "\n";
                bf.put(repl[i]);
            }
            state = SEARCHING;
            break;
        case FAILED_MATCH:
            assert(false);
            //state = SEARCHING;
            break;
        case POTENTIAL_MATCH:
            assert(false);
        }
        cur_len++;
    }
    bf.flushy();

    cerr << "size of buffer at end=" << bf.buffersize() << endl;
    truncate(bf.filename.c_str(), bf.putpos);
    return 0;
}