//terminal.h

#ifndef __TERMINAL_H
#define __TERMINAL_H

#include "platform.h"
#ifdef _WINDOWS
#include "process.h"

#ifndef TERMINAL_DEFAULT_CP
#define TERMINAL_DEFAULT_CP 866
#endif

class ITerminal
{
public:
    virtual ~ITerminal(){}
    virtual int WriteText(const char* pText) const = 0;
    virtual int ReadText(char* pBuf,uint uMaxLen) const = 0;
    virtual IProcess* GetProcess() const = 0;
    virtual int GetCodePage() const = 0;
    virtual void SetCodePage(int cp) = 0;

    virtual void SetReadLF(bool bRead = true) = 0;
    virtual void SetWriteAutoCRLF(bool bWrite = false) = 0;
};

class Terminal : public ITerminal
{
public:
    Terminal(IProcess* pCmd);
    virtual ~Terminal();

    virtual int WriteText(const char* pText) const;
    virtual int ReadText(char* pBuf,uint uMaxLen) const;
    virtual IProcess* GetProcess() const;
    virtual int GetCodePage() const;
    virtual void SetCodePage(int cp);

    virtual void SetReadLF(bool bRead = true);
    virtual void SetWriteAutoCRLF(bool bWrite = false);
private:
    IProcess* m_pCmd;
    int m_iCP;
    bool m_bReadLF;
    bool m_bWriteAutoCRLF;
public:
    static ITerminal* Create(bool bHidden = false,const char* cwd = NULL);
    static void Destroy(ITerminal* term);

    static Terminal& This();
    static void SetDefaultCP(int cp);
    static int GetDefaultCP();

    static void SetInternalCP(int cp);
    static int GetInternalCP();
private:
    static int s_iInternalCP;
    static int s_iDefaultCP;
};

#endif

#endif

//terminal.cpp

#include "terminal.h"

#ifdef _WINDOWS
#include "unicode.h"

Terminal::Terminal(IProcess* pCmd)
    : m_pCmd(pCmd)
{
    SetCodePage(GetDefaultCP());
    SetReadLF(true);
    SetWriteAutoCRLF(false);
}

Terminal::~Terminal()
{
}

int Terminal::WriteText(const char* pRawText) const
{
    //Process line feeds
    int iWritten;
    uint uTextLen = strlen(pRawText)+1;
    char* pText = new char[uTextLen + (m_bWriteAutoCRLF ? 2 : 1)]; //CR + null-terminator : auto_CRLF + null-terminator
    memcpy(pText,pRawText,uTextLen);
    if(m_bWriteAutoCRLF)
    {
        char* _end = &pText[uTextLen-1]; // points to null-terminator
        *_end++ = '\r';
        *_end++ = '\n';
        *_end++ = '\0';
    }
    else
    {
        char* _lf = strrchr(pText,'\n');
        if(_lf != NULL)
        {
            *_lf++ = '\r';
            *_lf++ = '\n';
            *_lf = '\0';
        }
    }

    if(GetCodePage() == GetInternalCP())
        iWritten = GetProcess()->Write(pText,strlen(pText));
    else
    {
        char* pBuf = encoding_convert(GetInternalCP(),GetCodePage(),pText);
        iWritten = GetProcess()->Write(pBuf,strlen(pBuf));
        delete[] pBuf;
    }
    delete[] pText;
    return iWritten;
}

int Terminal::ReadText(char* pBuf,uint uMaxLen) const
{
    char* pNewBuf = new char[uMaxLen];
    int iRead = GetProcess()->Read(pNewBuf,uMaxLen);
    if(iRead < 1)
    {
        delete[] pNewBuf;
        return iRead;
    }

    //Process line feeds
    char* _cr = strrchr(pNewBuf,'\r');
    if(_cr != NULL)
    {
        if(m_bReadLF) *_cr++ = '\n';
        *_cr = '\0';
    }

    char* pConvert;
    if(GetCodePage() == GetInternalCP())
        pConvert = _strdup(pNewBuf);
    else pConvert = encoding_convert(GetCodePage(),GetInternalCP(),pNewBuf);
    delete[] pNewBuf;
    strncpy(pBuf,pConvert,uMaxLen);

    delete[] pConvert;
    return iRead;
}

IProcess* Terminal::GetProcess() const
{
    return m_pCmd;
}

int Terminal::GetCodePage() const
{
    return m_iCP;
}

void Terminal::SetCodePage(int cp)
{
    m_iCP = cp;
}

void Terminal::SetReadLF(bool bRead)
{
    m_bReadLF = bRead;
}

void Terminal::SetWriteAutoCRLF(bool bWrite)
{
    m_bWriteAutoCRLF = bWrite;
}

ITerminal* Terminal::Create(bool bHidden,const char* cwd)
{
    char szCmdPath[MAX_PATH];
    HANDLE hChildIO[Process::STDMAX];
    HANDLE hParentIO[Process::STDMAX];
    ProcessConfig config;

    GetWindowsDirectory(szCmdPath,MAX_PATH);
    strcat(szCmdPath,"\\system32\\cmd.exe");
    config.SetExecutablePath(szCmdPath);

    config.params.m_bShowWindow = !bHidden;
    config.params.m_bUseStdHandles = true;
    config.params.m_bInheritHandles = true;
    Process::CreatePipedIO(hChildIO,hParentIO);
    Process* cmd = Process::Create(config,hChildIO,hParentIO);
    if(!cmd) return NULL;
    return new Terminal(cmd);
}

void Terminal::Destroy(ITerminal* iterm)
{
    Terminal* term = dynamic_cast<Terminal*>(iterm);
    Process* cmd = dynamic_cast<Process*>(iterm->GetProcess());
    cmd->Terminate(0);
    delete cmd;
    delete term;
}

static Terminal _this_terminal = Terminal(const_cast<Process*>(&Process::This()));

int Terminal::s_iInternalCP = INTERNAL_CP;
int Terminal::s_iDefaultCP = TERMINAL_DEFAULT_CP;

Terminal& Terminal::This()
{
    return _this_terminal;
}

void Terminal::SetInternalCP(int cp)
{
    s_iInternalCP = cp;
}

int Terminal::GetInternalCP()
{
    return s_iInternalCP;
}

void Terminal::SetDefaultCP(int cp)
{
    s_iDefaultCP = cp;
}

int Terminal::GetDefaultCP()
{
    return s_iDefaultCP;
}

#endif