#include "Serial.h"

namespace serial {

    std::size_t OBinaryFile::write(const std::byte* data, std::size_t size){
        return fwrite(data, sizeof(std::byte), size, m_file);
    }

    OBinaryFile::OBinaryFile(const std::string& filename, Mode mode){
        if(mode==Truncate){
            m_file= fopen(filename.data(),"wb");
        }else if(mode==Append){
            m_file= fopen(filename.data(),"a");
        }
    }
    OBinaryFile::~OBinaryFile(){
      fclose(m_file);
    }


    OBinaryFile& operator<<(OBinaryFile& file, std::byte x){
        file.write(&x,1);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, uint8_t x){
        std::byte a = { static_cast<std::byte>(x) };
        file.write(&a, 1);
        return file;
    }


    OBinaryFile& operator<<(OBinaryFile& file, int8_t x){
        std::byte a = { static_cast<std::byte>(x) };
        file.write(&a, 1);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, uint16_t x){
        constexpr std::size_t size=sizeof(uint16_t);
        std::byte array[size];
        array[0]=static_cast<std::byte>(x>>8);
        array[1]=static_cast<std::byte>(x&0xff);
        file.write(array,size);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, int16_t x){
        constexpr std::size_t size=sizeof(uint16_t);
        std::byte array[size];
        array[0]=static_cast<std::byte>(x>>8);
        array[1]=static_cast<std::byte>(x&0xff);
        file.write(array,size);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, uint32_t x){
        constexpr std::size_t size=sizeof(uint32_t);
        std::byte array[size];
        array[0]=static_cast<std::byte>((x>>24)&0xff);
        array[1]=static_cast<std::byte>((x>>16)&0xff);
        array[2]=static_cast<std::byte>((x>>8)&0xff);
        array[3]=static_cast<std::byte>(x&0xff);
        file.write(array,size);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, int32_t x){
        constexpr std::size_t size=sizeof(int32_t);
        std::byte array[size];
        array[0]=static_cast<std::byte>((x>>24)&0xff);
        array[1]=static_cast<std::byte>((x>>16)&0xff);
        array[2]=static_cast<std::byte>((x>>8)&0xff);
        array[3]=static_cast<std::byte>(x&0xff);
        file.write(array,size);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, uint64_t x){
        constexpr std::size_t size=sizeof(uint64_t);
        std::byte array[size];
        array[0]=static_cast<std::byte>((x>>56)&0xff);
        array[1]=static_cast<std::byte>((x>>48)&0xff);
        array[2]=static_cast<std::byte>((x>>40)&0xff);
        array[3]=static_cast<std::byte>((x>>32)&0xff);
        array[4]=static_cast<std::byte>((x>>24)&0xff);
        array[5]=static_cast<std::byte>((x>>16)&0xff);
        array[6]=static_cast<std::byte>((x>>8)&0xff);
        array[7]=static_cast<std::byte>(x&0xff);
        file.write(array,size);
        return file;
    }
    OBinaryFile& operator<<(OBinaryFile& file, int64_t x){
        constexpr std::size_t size=sizeof(int64_t);
        std::byte array[size];
        array[0]=static_cast<std::byte>((x>>56)&0xff);
        array[1]=static_cast<std::byte>((x>>48)&0xff);
        array[2]=static_cast<std::byte>((x>>40)&0xff);
        array[3]=static_cast<std::byte>((x>>32)&0xff);
        array[4]=static_cast<std::byte>((x>>24)&0xff);
        array[5]=static_cast<std::byte>((x>>16)&0xff);
        array[6]=static_cast<std::byte>((x>>8)&0xff);
        array[7]=static_cast<std::byte>(x&0xff);
        file.write(array,size);
        return file;
    }
    OBinaryFile& operator<<(OBinaryFile& file, char x){
        std::byte charToSend=static_cast<std::byte>(x);
        file.write(&charToSend,1);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, float x){
        constexpr std::size_t size=sizeof(float);
        uint32_t tmp;
        memcpy(&tmp,&x,size);
        std::byte array[size];
        array[0]=static_cast<std::byte>((tmp>>24)&0xff);
        array[1]=static_cast<std::byte>((tmp>>16)&0xff);
        array[2]=static_cast<std::byte>((tmp>>8)&0xff);
        array[3]=static_cast<std::byte>(tmp&0xff);
        file.write(array,size);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, double x){
        constexpr std::size_t size=sizeof(double);
        uint64_t tmp;
        memcpy(&tmp,&x,size);
        std::byte array[size];
        array[0]=static_cast<std::byte>((tmp>>56)&0xff);
        array[1]=static_cast<std::byte>((tmp>>48)&0xff);
        array[2]=static_cast<std::byte>((tmp>>40)&0xff);
        array[3]=static_cast<std::byte>((tmp>>32)&0xff);
        array[4]=static_cast<std::byte>((tmp>>24)&0xff);
        array[5]=static_cast<std::byte>((tmp>>16)&0xff);
        array[6]=static_cast<std::byte>((tmp>>8)&0xff);
        array[7]=static_cast<std::byte>(tmp&0xff);
        file.write(array,size);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, bool x){
        std::byte valeurVerite{0};
        if(x==true){
            valeurVerite=static_cast<std::byte>(1);
        }
        else if(x==false){
            valeurVerite=static_cast<std::byte>(0);
        }
        file.write(&valeurVerite,1);
        return file;
    }

    OBinaryFile& operator<<(OBinaryFile& file, const std::string& x){
        //Send the size of string.
        int8_t size = x.size();
        file << size;

        //Write all character in string.
        for(int8_t i = 0; i < size; ++i){
            file << x[i];
        }

        return file;
    }

    std::size_t IBinaryFile::read(std::byte* data, std::size_t size){
        return fread(data, sizeof(std::byte), size, m_file);
    }

    IBinaryFile::IBinaryFile(const std::string& filename){
      m_file = fopen(filename.data(), "rb");
    }
    IBinaryFile::~IBinaryFile(){
      fclose(m_file);
    }
    IBinaryFile& operator>>(IBinaryFile& file, int8_t& x){
        std::byte read;
        file.read(&read, 1);
        x = static_cast<int8_t>(read);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, uint8_t& x){
        std::byte read;
        file.read(&read, 1);
        x = static_cast<uint8_t>(read);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, int16_t& x){
        constexpr std::size_t size=sizeof(int16_t);
        std::byte read[size];
        file.read(read,size);
        x=(static_cast<int16_t>(read[0]) << 8)|
           static_cast<int16_t>(read[1]);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, uint16_t& x){
        constexpr std::size_t=sizeof(uint16_t);
        std::byte read[size];
        file.read(read,size);
        x=(static_cast<uint16_t>(read[0]) << 8)|
           static_cast<uint16_t>(read[1]);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, int32_t& x){
        constexpr std::size_t size=sizeof(int32_t);
        std::byte read[size];
        file.read(read,size);
        x =  static_cast<int32_t>(read[3])      |
            (static_cast<int32_t>(read[2])<<8)  |
            (static_cast<int32_t>(read[1])<<16) |
            (static_cast<int32_t>(read[0])<<24);
        return file;
    }

    IBinaryFile& operator>>(IBinaryFile& file, uint32_t& x){
        constexpr std::size_t size=sizeof(uint32_t);
        std::byte read[size];
        file.read(read,size);
        x =  static_cast<uint32_t>(read[3])      |
            (static_cast<uint32_t>(read[2])<<8)  |
            (static_cast<uint32_t>(read[1])<<16) |
            (static_cast<uint32_t>(read[0])<<24);
        return file;
    }

    IBinaryFile& operator>>(IBinaryFile& file, int64_t& x){
        constexpr std::size_t size=sizeof(int64_t);
        std::byte read[size];
        file.read(read,size);
        x =  static_cast<int64_t>(read[7])      |
            (static_cast<int64_t>(read[6])<<8)  |
            (static_cast<int64_t>(read[5])<<16) |
            (static_cast<int64_t>(read[4])<<24) |
            (static_cast<int64_t>(read[3])<<32) |
            (static_cast<int64_t>(read[2])<<40) |
            (static_cast<int64_t>(read[1])<<48) |
            (static_cast<int64_t>(read[0])<<56);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, uint64_t& x){
        constexpr std::size_t size=sizeof(uint64_t);
        std::byte read[size];
        file.read(read,size);
        x =  static_cast<uint64_t>(read[7])      |
            (static_cast<uint64_t>(read[6])<<8)  |
            (static_cast<uint64_t>(read[5])<<16) |
            (static_cast<uint64_t>(read[4])<<24) |
            (static_cast<uint64_t>(read[3])<<32) |
            (static_cast<uint64_t>(read[2])<<40) |
            (static_cast<uint64_t>(read[1])<<48) |
            (static_cast<uint64_t>(read[0])<<56);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, char& x){
        constexpr std::size_t size=sizeof(char);
        std::byte read;
        file.read(&read,size);
        x=static_cast<char>(read);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, float& x){
        constexpr std::size_t size=sizeof(float);
        std::byte read[size];
        file.read(read,size);
        uint32_t tmp;
        tmp =    static_cast<uint32_t>(read[3])      |
                (static_cast<uint32_t>(read[2])<<8)  |
                (static_cast<uint32_t>(read[1])<<16) |
                (static_cast<uint32_t>(read[0])<<24);
        memcpy(&x,&tmp,size);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, double& x){
        constexpr std::size_t size=sizeof(double);
        std::byte read[size];
        file.read(read,size);
        uint64_t tmp;
        tmp =    static_cast<uint64_t>(read[7])      |
                (static_cast<uint64_t>(read[6])<<8)  |
                (static_cast<uint64_t>(read[5])<<16) |
                (static_cast<uint64_t>(read[4])<<24) |
                (static_cast<uint64_t>(read[3])<<32) |
                (static_cast<uint64_t>(read[2])<<40) |
                (static_cast<uint64_t>(read[1])<<48) |
                (static_cast<uint64_t>(read[0])<<56);
        memcpy(&x,&tmp,size);
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, bool& x){
        std::byte read;
        file.read(&read,1);
        if(static_cast<int>(read)>0){
            x=true;
        }
        else{
            x=false;
        }
        return file;
    }
    IBinaryFile& operator>>(IBinaryFile& file, std::string& x){
        x.clear(); //Clean the old string.

        //Recv the size of string.
        int8_t size;
        file >> size;

        //Write all character in string.
        for(int8_t i = 0; i < size; ++i){
            char car;
            file >> car;
            x.push_back(car);
        }

        return file;
    }
}