#include "HGSane.h"
#include "HGSaneImpl.hpp"

HGResult HGAPI HGSane_CreateManager(HGSaneManager *manager)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = new HGSaneManagerImpl;
    HGResult ret = managerImpl->Create();
    if (HGBASE_ERR_OK != ret)
    {
        delete managerImpl;
        return ret;
    }

    *manager = (HGSaneManager)managerImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_DestroyManager(HGSaneManager manager)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = (HGSaneManagerImpl*)manager;
    HGResult ret = managerImpl->Destroy();
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    delete managerImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_GetSourceCount(HGSaneManager manager, HGUInt *count)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = (HGSaneManagerImpl*)manager;
    return managerImpl->GetSourceCount(count);
}

HGResult HGAPI HGSane_GetSourceNameWithIndex(HGSaneManager manager, HGUInt index, HGChar *name, HGUInt maxLen)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = (HGSaneManagerImpl*)manager;
    return managerImpl->GetSourceName(index, name, maxLen);
}

HGResult HGAPI HGSane_OpenSource(HGSaneManager manager, HGUInt index, HGSaneSource* source)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = (HGSaneManagerImpl*)manager;
    HGSaneSourceImpl *sourceImpl = NULL;
    HGResult ret = managerImpl->OpenSource(index, &sourceImpl);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    *source = (HGSaneSource)sourceImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_OpenDefaultSource(HGSaneManager manager, HGSaneSource* source)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = (HGSaneManagerImpl*)manager;
    HGSaneSourceImpl *sourceImpl = NULL;
    HGResult ret = managerImpl->OpenDefaultSource(&sourceImpl);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    *source = (HGSaneSource)sourceImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_OpenSelectedSource(HGSaneManager manager, HGWindow parent, HGSaneSource* source)
{
    if (NULL == manager)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneManagerImpl *managerImpl = (HGSaneManagerImpl*)manager;
    HGSaneSourceImpl *sourceImpl = NULL;
    HGResult ret = managerImpl->OpenSelectedSource(parent, &sourceImpl);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    *source = (HGSaneSource)sourceImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_CloseSource(HGSaneSource source)
{
    if (NULL == source)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneSourceImpl* saneSourceImpl = (HGSaneSourceImpl*)source;
    return saneSourceImpl->Close();
}

HGResult HGAPI HGSane_GetSourceName(HGSaneSource source, HGChar *name, HGUInt maxLen)
{
    if (NULL == source)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneSourceImpl* saneSourceImpl = (HGSaneSourceImpl*)source;
    return saneSourceImpl->GetName(name, maxLen);
}

HGResult HGAPI HGSane_GetDeviceCount(HGSaneSource source, HGUInt* count)
{
    if (NULL == source)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneSourceImpl* saneSourceImpl = (HGSaneSourceImpl*)source;
    return saneSourceImpl->GetDeviceCount(count);
}

HGResult HGAPI HGSane_GetDeviceNameWithIndex(HGSaneSource source, HGUInt index, HGChar* name, HGUInt maxLen)
{
    if (NULL == source)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneSourceImpl* saneSourceImpl = (HGSaneSourceImpl*)source;
    return saneSourceImpl->GetDeviceName(index, name, maxLen);
}

HGResult HGAPI HGSane_OpenDevice(HGSaneSource source, HGUInt index, HGSaneDevice* dev, HGChar* errInfo, HGUInt errInfoLen)
{
    if (NULL == source)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneSourceImpl* saneSourceImpl = (HGSaneSourceImpl*)source;
    class HGSaneDeviceImpl* saneDeviceImpl = NULL;
    HGResult ret = saneSourceImpl->OpenDevice(index, &saneDeviceImpl, errInfo, errInfoLen);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    *dev = (HGSaneDevice)saneDeviceImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_OpenSelectedDevice(HGSaneSource source, HGWindow parent, HGSaneDevice* dev)
{
    if (NULL == source)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneSourceImpl* saneSourceImpl = (HGSaneSourceImpl*)source;
    class HGSaneDeviceImpl* saneDeviceImpl = NULL;
    HGResult ret = saneSourceImpl->OpenSelectedDevice(parent, &saneDeviceImpl);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    *dev = (HGSaneDevice)saneDeviceImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGSane_CloseDevice(HGSaneDevice dev)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->Close();
}

HGResult HGAPI HGSane_GetDeviceName(HGSaneDevice dev, HGChar* name, HGUInt maxLen)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->GetName(name, maxLen);
}

HGResult HGAPI HGSane_GetDeviceCustomInfo(HGSaneDevice dev, HGSaneDeviceCustomInfo *info)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->GetCustomInfo(info);
}

HGResult HGAPI HGSane_ShowDeviceSettingDlg(HGSaneDevice dev, HGWindow parent)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->ShowSettingDlg(parent);
}

HGResult HGAPI HGSane_Login(HGSaneDevice dev, const HGChar *user, const HGChar *pwd)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->Login(user, pwd);
}

HGResult HGAPI HGSane_Logout(HGSaneDevice dev)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->Logout();
}

HGResult HGAPI HGSane_ClearRollerCount(HGSaneDevice dev)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->ClearRollerCount();
}

HGResult HGAPI HGSane_GetDeviceRollerLife(HGSaneDevice dev, HGInt *rollerLife)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->GetRollerLife(rollerLife);
}

HGResult HGAPI HGSane_GetDriverLog(HGSaneDevice dev, const HGChar *fileName)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->GetDriverLog(fileName);
}

HGResult HGAPI HGSane_ClearDriverLog(HGSaneDevice dev)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->ClearDriverLog();
}

HGResult HGAPI HGSane_GetDeviceLog(HGSaneDevice dev, const HGChar *fileName)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->GetDeviceLog(fileName);
}

HGResult HGAPI HGSane_ClearDeviceLog(HGSaneDevice dev)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->ClearDeviceLog();
}

HGResult HGAPI HGSane_StartDevice(HGSaneDevice dev, HGWindow parent, HGSane_DeviceEventFunc eventFunc, HGPointer eventParam,
    HGSane_DeviceImageFunc imageFunc, HGPointer imageParam)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->Start(parent, eventFunc, eventParam, imageFunc, imageParam);
}

HGResult HGAPI HGSane_StartDeviceWithSingleScan(HGSaneDevice dev, HGWindow parent, HGSane_DeviceEventFunc eventFunc, HGPointer eventParam,
    HGSane_DeviceImageFunc imageFunc, HGPointer imageParam)
{
    if (NULL == dev)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGSaneDeviceImpl* saneDeviceImpl = (HGSaneDeviceImpl*)dev;
    return saneDeviceImpl->StartWithSingleScan(parent, eventFunc, eventParam, imageFunc, imageParam);
}