#include <windows.h>

#include "MicomApi.h"

HANDLE vhCom = NULL;
MPacket mReadPac;

CBReadMicom fCBReadMicom = NULL;
CBWriteMicom fCBWriteMicom = NULL;

BYTE GetCheckSum(BYTE* buffer, BYTE len)
{
    BYTE result = 0;

    for (BYTE i=0;i<len;i++)
        result ^= buffer[i];

    return result;
}

DWORD SendToMicom(BYTE* mes, BYTE len)
{
    DWORD dwBytesWritten = 0;

    if (vhCom < 0) return 0;

    if (WriteFile(vhCom, mes, len, &dwBytesWritten, NULL))
        Sleep(8);

    return dwBytesWritten;
}

#ifdef __cplusplus
extern "C" {
#endif

HANDLE WINAPI GetMicomHandle()
{
    return vhCom;
}

int WINAPI SetCallBackRead(CBReadMicom cbReadMicom)
{
    fCBReadMicom = cbReadMicom;
    return 0;
}

int WINAPI SetCallBackWrite(CBWriteMicom cbWriteMicom)
{
    fCBWriteMicom = cbWriteMicom;
    return 0;
}

DWORD WINAPI SendCommandEx(BYTE mgr, BYTE cmd, BYTE len, BYTE* buffer)
{
    if (vhCom == NULL) {
        MessageBox(NULL, _T("Non connecté ..."), NULL, MB_OK|MB_ICONERROR);
        return 0;
    }

    BYTE* mes = new BYTE[len + 5];
    mes[0] = 0xAA;
    mes[1] = (mgr << 4) ^ 1;
    mes[2] = cmd;
    mes[3] = len;
    if (len > 0)
        memcpy(&mes[4], buffer, len);
    mes[len + 4] = GetCheckSum(mes, len + 4);

    DWORD res = SendToMicom(mes, len + 5);
    delete[] mes;

    return res;
}

DWORD WINAPI SendReadCmd(BYTE mgr, DWORD addr, BYTE len)
{
    if (vhCom == NULL) {
        MessageBox(NULL, _T("Non connecté ..."), NULL, MB_OK|MB_ICONERROR);
        return 0;
    }

    BYTE* mes = new BYTE[9];
    mes[0] = 0xAA;
    mes[1] = (mgr << 4) ^ 5;
    mes[2] = len;
    mes[3] = 4;
    *(DWORD*)&mes[4] = addr;
    mes[8] = GetCheckSum(mes, 8);

    DWORD res = SendToMicom(mes, 9);
    delete[] mes;

    return res;
}

DWORD WINAPI SendWriteCmd(BYTE mgr, DWORD addr, BYTE len, BYTE* buffer)
{
    if (vhCom == NULL) {
        MessageBox(NULL, _T("Non connecté ..."), NULL, MB_OK|MB_ICONERROR);
        return 0;
    }

    BYTE* mes = new BYTE[len + 9];
    mes[0] = 0xAA;
    mes[1] = (mgr << 4) ^ 6;
    mes[2] = len;
    mes[3] = len + 4;
    *(DWORD*)&mes[4] = addr;
    if (len > 0)
        memcpy(&mes[8], buffer, len);
    mes[len + 8] = GetCheckSum(mes, len + 8);

    DWORD res = SendToMicom(mes, len + 9);
    delete[] mes;

    return res;
}

//////////////////////////////////////////////////////
// coredll
//////////////////////////////////////////////////////

// CreateFileW
HANDLE WINAPI __E__CreateFileW__(
    LPCWSTR lpFileName,
    DWORD dwDesiredAccess,
    DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    DWORD dwCreationDisposition,
    DWORD dwFlagsAndAttributes,
    HANDLE hTemplateFile
    )
{
    HANDLE h = CreateFileW(lpFileName,
                        dwDesiredAccess,
                        dwShareMode,
                        lpSecurityAttributes,
                        dwCreationDisposition,
                        dwFlagsAndAttributes,
                        hTemplateFile);

    if (vhCom == NULL && h != INVALID_HANDLE_VALUE &&
            wcscmp(lpFileName, L"COM2:") == 0) {
        vhCom = h;
        mReadPac.rLen = 0;
    }

    return h;
}

// ReadFile
BOOL WINAPI __E__ReadFile__(
    HANDLE hFile,
    __out_bcount(nNumberOfBytesToRead) LPVOID lpBuffer,
    DWORD nNumberOfBytesToRead,
    LPDWORD lpNumberOfBytesRead,
    LPOVERLAPPED lpOverlapped
    )
{
    if (hFile == vhCom && fCBReadMicom) {
        BYTE* data = (BYTE*)lpBuffer;
        int res = 0;

        if (nNumberOfBytesToRead == 1 && mReadPac.rLen == 0) {
            if (!ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped))
                return FALSE;

            if (data[0] == 0xAA) {
                mReadPac.rData[mReadPac.rLen] = 0xAA;
                mReadPac.rLen += *lpNumberOfBytesRead;
            }
        } else if (nNumberOfBytesToRead == 3 && mReadPac.rLen == 1) {
            if (!ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped))
                return FALSE;

            memcpy(&mReadPac.rData[mReadPac.rLen], data, *lpNumberOfBytesRead);
            mReadPac.rLen += *lpNumberOfBytesRead;

            mReadPac.mgr = (((mReadPac.rData[1] & 0xf0) >> 4) & 0xf);
            mReadPac.grp = (mReadPac.rData[1] & 0xf);
            mReadPac.cmd = mReadPac.rData[2];
            mReadPac.len = mReadPac.rData[3];
        } else if (mReadPac.rLen > 3) {
            if (!ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped))
                return FALSE;

            memcpy(&mReadPac.rData[mReadPac.rLen], data, *lpNumberOfBytesRead);
            mReadPac.rLen += *lpNumberOfBytesRead;

            if (mReadPac.rLen == (mReadPac.len + 5)) {
                mReadPac.checkSum = mReadPac.rData[mReadPac.rLen - 1];
                res = fCBReadMicom(&mReadPac);
                mReadPac.rLen = 0;

                if (res)
                    data[*lpNumberOfBytesRead - 1] += 1;
            }
        }
    }

    return TRUE;
}

BOOL WINAPI __E__WriteFile__(
    HANDLE hFile,
    __in_bcount(nNumberOfBytesToWrite) LPCVOID lpBuffer,
    DWORD nNumberOfBytesToWrite,
    LPDWORD lpNumberOfBytesWritten,
    LPOVERLAPPED lpOverlapped
    )
{
    if (hFile == vhCom && fCBWriteMicom) {
        BYTE* data = (BYTE*)lpBuffer;
        if (data[0] = 0xAA) {
            MPacket pac;
            pac.rLen = *lpNumberOfBytesWritten;
            pac.rData = data;

            pac.mgr = (((pac.rData[1] & 0xf0) >> 4) & 0xf);
            pac.grp = (pac.rData[1] & 0xf);
            pac.cmd = pac.rData[2];
            pac.len = pac.rData[3];
            pac.data = &pac.rData[4];
            pac.checkSum = pac.rData[pac.rLen - 1];

            if (fCBWriteMicom(&pac)) {
                *lpNumberOfBytesWritten = nNumberOfBytesToWrite;
                return TRUE;
            }
        }
    }

    return WriteFile(hFile,
                        lpBuffer,
                        nNumberOfBytesToWrite,
                        lpNumberOfBytesWritten,
                        lpOverlapped);
}

BOOL WINAPI __E__CloseHandle__(HANDLE hObject)
{
    if (vhCom == hObject)
        vhCom = NULL;

    return CloseHandle(hObject);
}

#ifdef __cplusplus
}
#endif