/*
 * TWAIN Plug-in
 * Copyright (C) 1999 Craig Setera
 * Craig Setera <setera@home.com>
 * 03/31/1999
 *
 * Updated for Mac OS X support
 * Brion Vibber <brion@pobox.com>
 * 07/22/2004
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

/*
 * Windows platform-specific code
 */

#include "config.h"

#include <libgimp/gimp.h>

#include "tw_platform.h"
#include "tw_func.h"
#include "tw_util.h"
#include "tw_local.h"

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int twainMessageLoop(pTW_SESSION);
int TwainProcessMessage(LPMSG lpMsg, pTW_SESSION twSession);

extern pTW_SESSION initializeTwain ();
#ifdef _DEBUG
extern void setRunMode(char *argv[]);
#endif


#define APP_NAME "TWAIN"
#define SHOW_WINDOW 0
#define WM_TRANSFER_IMAGE (WM_USER + 100)

/* main bits */
static HWND        hwnd = NULL;
static HINSTANCE   hInst = NULL;

/* Storage for the DLL handle */
static HINSTANCE hDLL = NULL;

/* Storage for the entry point into the DSM */
static DSMENTRYPROC dsmEntryPoint = NULL;


/*
 * callDSM
 *
 * Call the specified function on the data source manager.
 */
TW_UINT16
callDSM(pTW_IDENTITY pOrigin,
 pTW_IDENTITY pDest,
 TW_UINT32    DG,
 TW_UINT16    DAT,
 TW_UINT16    MSG,
 TW_MEMREF    pData)
{
  /* Call the function */
  return (*dsmEntryPoint) (pOrigin, pDest, DG, DAT, MSG, pData);
}

/*
 * twainIsAvailable
 *
 * Return boolean indicating whether TWAIN is available
 */
int
twainIsAvailable(void)
{
  /* Already loaded? */
  if (dsmEntryPoint) {
    return TRUE;
  }

  /* Attempt to load the library */
  hDLL = LoadLibraryW (TWAIN_DLL_NAME_W);
  if (hDLL == NULL)
    return FALSE;

  /* Look up the entry point for use */
  dsmEntryPoint = (DSMENTRYPROC) GetProcAddress(hDLL, "DSM_Entry");
  if (dsmEntryPoint == NULL)
    return FALSE;

  return TRUE;
}

TW_HANDLE
twainAllocHandle (size_t size)
{
  return GlobalAlloc(GHND, size);
}

TW_MEMREF
twainLockHandle (TW_HANDLE handle)
{
  return GlobalLock (handle);
}

void
twainUnlockHandle (TW_HANDLE handle)
{
  GlobalUnlock (handle);
}

void
twainFreeHandle (TW_HANDLE handle)
{
  GlobalFree (handle);
}

gboolean
twainSetupCallback (pTW_SESSION twSession)
{
  /* Callbacks go through the window messaging system */
  return TRUE;
}

/*
 * unloadTwainLibrary
 *
 * Unload the TWAIN dynamic link library
 */
int
unloadTwainLibrary(pTW_SESSION twSession)
{
  /* Explicitly free the SM library */
  if (hDLL) {
    FreeLibrary(hDLL);
    hDLL=NULL;
  }

  /* the data source id will no longer be valid after
   * twain is killed.  If the id is left around the
   * data source can not be found or opened
 */
  DS_IDENTITY(twSession)->Id = 0;

 /* We are now back at state 1 */
  twSession->twainState = 1;
  LogMessage("Source Manager successfully closed\n");

  return TRUE;
}

/*
 * TwainProcessMessage
 *
 * Returns TRUE if the application should process message as usual.
 * Returns FALSE if the application should skip processing of this message
 */
int
TwainProcessMessage(LPMSG lpMsg, pTW_SESSION twSession)
{
  TW_EVENT   twEvent;

  twSession->twRC = TWRC_NOTDSEVENT;

  /* Only ask Source Manager to process event if there is a Source connected. */
  if (DSM_IS_OPEN(twSession) && DS_IS_OPEN(twSession)) {
  /*
   * A Source provides a modeless dialog box as its user interface.
   * The following call relays Windows messages down to the Source's
   * UI that were intended for its dialog box.  It also retrieves TWAIN
   * messages sent from the Source to our Application.
 */
  twEvent.pEvent = (TW_MEMREF) lpMsg;
  twSession->twRC = callDSM(APP_IDENTITY(twSession), DS_IDENTITY(twSession),
   DG_CONTROL, DAT_EVENT, MSG_PROCESSEVENT,
   (TW_MEMREF) &twEvent);

  /* Check the return code */
  if (twSession->twRC == TWRC_NOTDSEVENT) {
   return FALSE;
  }

  /* Process the message as necessary */
  processTwainMessage(twEvent.TWMessage, twSession);
  }

  /* tell the caller what happened */
  return (twSession->twRC == TWRC_DSEVENT);
}

/*
 * twainMessageLoop
 *
 * Process Win32 window messages and provide special handling
 * of TWAIN specific messages.  This loop will not exit until
 * the application exits.
 */
int
twainMessageLoop(pTW_SESSION twSession)
{
  MSG msg;

  while (GetMessage(&msg, NULL, 0, 0)) {
    if (DS_IS_CLOSED(twSession) || !TwainProcessMessage(&msg, twSession)) {
      TranslateMessage((LPMSG)&msg);
      DispatchMessage(&msg);
    }
  }

  return msg.wParam;
}

/*
 * LogLastWinError
 *
 * Log the last Windows error as returned by
 * GetLastError.
 */
void
LogLastWinError(void)
{
 LPVOID lpMsgBuf;

 FormatMessage(
  FORMAT_MESSAGE_ALLOCATE_BUFFER |
  FORMAT_MESSAGE_FROM_SYSTEM |
  FORMAT_MESSAGE_IGNORE_INSERTS,
  NULL,
  GetLastError(),
  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
  (LPTSTR) &lpMsgBuf,
  0,
  NULL
  );

 LogMessage("%s\n", lpMsgBuf);

 /* Free the buffer. */
 LocalFree( lpMsgBuf );
}

void twainQuitApplication (void)
{
  PostQuitMessage (0);
}


/******************************************************************
 * Win32 setup...
 ******************************************************************/

/*
 * InitApplication
 *
 * Initialize window data and register the window class
 */
BOOL
InitApplication(HINSTANCE hInstance)
{
  WNDCLASS wc;
  BOOL retValue;

  /*
   * Fill in window class structure with parameters to describe
   * the main window.
   */
  wc.style = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc = (WNDPROC) WndProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hInstance = hInstance;
  wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  wc.lpszClassName = APP_NAME;
  wc.lpszMenuName = NULL;

  /* Register the window class and stash success/failure code. */
  retValue = RegisterClass(&wc);

  /* Log error */
  if (!retValue)
    LogLastWinError();

  return retValue;
}

/*
 * InitInstance
 *
 * Create the main window for the application.  Used to
 * interface with the TWAIN datasource.
 */
BOOL
InitInstance(HINSTANCE hInstance, int nCmdShow, pTW_SESSION twSession)
{
  /* Create our window */
  hwnd = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
        NULL, NULL, hInstance, NULL);

  if (!hwnd) {
    return (FALSE);
  }

  /* Register our window handle with the TWAIN
   * support.
   */
  registerWindowHandle(twSession, hwnd);

  /* Schedule the image transfer by posting a message */
  PostMessage(hwnd, WM_TRANSFER_IMAGE, 0, 0);

  ShowWindow(hwnd, nCmdShow);
  UpdateWindow(hwnd);

  return TRUE;
}

/*
 * twainWinMain
 *
 * This is the function that represents the code that
 * would normally reside in WinMain (see above).  This
 * function will get called during run() in order to set
 * up the windowing environment necessary for TWAIN to
 * operate.
 */
int
twainMain (void)
{
  /* Initialize the twain information */
  pTW_SESSION twSession = initializeTwain();

  /* Since we are not using our own WinMain anymore where we
     could get hInst we get it here using GetModuleHandleW. */
  if (!hInst)
    hInst = GetModuleHandleW(NULL);

  /* Perform instance initialization */
  if (!InitApplication(hInst))
    return (FALSE);

  /* Perform application initialization */
  if (!InitInstance(hInst, SHOW_WINDOW, twSession))
    return (FALSE);

  /*
   * Call the main message processing loop...
   * This call will not return until the application
   * exits.
   */
  return twainMessageLoop(twSession);
}

/*
 * WndProc
 *
 * Process window message for the main window.
 */
LRESULT CALLBACK
WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  switch (message) {

  case WM_TRANSFER_IMAGE:
    /* Get an image */
    scanImage ();
    break;

  case WM_DESTROY:
    LogMessage("Exiting application\n");
    PostQuitMessage(0);
    break;

  default:
    return (DefWindowProc(hWnd, message, wParam, lParam));
  }
  return 0;
}