/*
 * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * - Redistribution of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * 
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
 * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
 * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
 * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
 * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
 * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 * 
 * You acknowledge that this software is not designed or intended for use
 * in the design, construction, operation or maintenance of any nuclear
 * facility.
 * 
 * Sun gratefully acknowledges that this software was originally authored
 * and developed by Kenneth Bradley Russell and Christopher John Kline.
 */

package net.java.games.jogl.impl.windows;

import java.awt.Component;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.Rectangle;
import java.io.File;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Collection;
import java.util.Iterator;
import net.java.games.jogl.*;
import net.java.games.jogl.impl.*;

public class WindowsGLContextFactory extends GLContextFactory {
  private static final boolean DEBUG = Debug.debug("WindowsGLContextFactory");
  private static final boolean VERBOSE = Debug.verbose();

  static {
    NativeLibLoader.load();
  }

  // On Windows we want to be able to use some extension routines like
  // wglChoosePixelFormatARB during the creation of the user's first
  // GLContext. However, this and other routines' function pointers
  // aren't loaded by the driver until the first OpenGL context is
  // created. The standard way of working around this chicken-and-egg
  // problem is to create a dummy window, show it, send it a paint
  // message, create an OpenGL context, fetch the needed function
  // pointers, and then destroy the dummy window and context. It turns
  // out that ATI cards need the dummy context to be current while
  // wglChoosePixelFormatARB is called, so we cache the extension
  // strings the dummy context reports as being available.
  private static Map/*<GraphicsDevice, GL>*/     dummyContextMap    = new HashMap();
  private static Map/*<GraphicsDevice, String>*/ dummyExtensionsMap = new HashMap();
  private static Set/*<GraphicsDevice    >*/     pendingContextSet  = new HashSet();
  
  public WindowsGLContextFactory() {
    AccessController.doPrivileged( new PrivilegedAction() {
      public Object run() {
        // Test for whether we should enable the single-threaded
        // workaround for ATI cards. It appears that if we make any
        // OpenGL context current on more than one thread on ATI cards
        // on Windows then we see random failures like the inability
        // to create more OpenGL contexts, or having just the next
        // OpenGL SetPixelFormat operation fail with a GetNextError()
        // code of 0 (but subsequent ones on subsequently-created
        // windows succeed). These kinds of failures are obviously due
        // to bugs in ATI's OpenGL drivers. Through trial and error it
        // was found that specifying
        // -DJOGL_SINGLE_THREADED_WORKAROUND=true on the command line
        // caused these problems to completely disappear. Therefore at
        // least on Windows we try to enable the single-threaded
        // workaround before creating any OpenGL contexts. In the
        // future, if problems are encountered on other platforms and
        // -DJOGL_SINGLE_THREADED_WORKAROUND=true works around them,
        // we may want to implement a workaround like this on other
        // platforms.
        
        // The algorithm here is to try to find the system directory
        // (assuming it is on the same drive as TMPDIR, exposed
        // through the system property java.io.tmpdir) and see whether
        // a known file in the ATI drivers is present; if it is, we
        // enable the single-threaded workaround.

        // If any path down this code fails, we simply bail out -- we
        // don't go to great lengths to figure out if the ATI drivers
        // are present. We could add more checks here in the future if
        // these appear to be insufficient.

        String tmpDirProp = System.getProperty("java.io.tmpdir");
        if (tmpDirProp != null) {
          File file = new File(tmpDirProp);
          if (file.isAbsolute()) {
            File parent = null;
            do {
              parent = file.getParentFile();
              if (parent != null) {
                file = parent;
              }
            } while (parent != null);
            // Now the file contains just the drive letter
            file = new File(new File(new File(file, "windows"), "system32"), "atioglxx.dll");
            if (file.exists()) {
              SingleThreadedWorkaround.shouldDoWorkaround();
            }
          }
        }

        return( null );
      }
    }); 
  }
  
  public GraphicsConfiguration chooseGraphicsConfiguration(GLCapabilities capabilities,
                                                           GLCapabilitiesChooser chooser,
                                                           GraphicsDevice device) {
    return null;
  }

  public GLDrawable getGLDrawable(Object target,
                                  GLCapabilities capabilities,
                                  GLCapabilitiesChooser chooser) {
    if (target == null) {
      throw new IllegalArgumentException("Null target");
    }
    if (!(target instanceof Component)) {
      throw new IllegalArgumentException("GLDrawables not supported for objects of type " +
                                         target.getClass().getName() + " (only Components are supported in this implementation)");
    }
    return new WindowsOnscreenGLDrawable((Component) target, capabilities, chooser);
  }

  public GLDrawableImpl createOffscreenDrawable(GLCapabilities capabilities,
                                                GLCapabilitiesChooser chooser) {
    return new WindowsOffscreenGLDrawable(capabilities, chooser);
  }

  static String wglGetLastError() {
    int err = WGL.GetLastError();
    String detail = null;
    switch (err) {
      case WGL.ERROR_INVALID_PIXEL_FORMAT: detail = "ERROR_INVALID_PIXEL_FORMAT";       break;
      case WGL.ERROR_NO_SYSTEM_RESOURCES:  detail = "ERROR_NO_SYSTEM_RESOURCES";        break;
      case WGL.ERROR_INVALID_DATA:         detail = "ERROR_INVALID_DATA";               break;
      case WGL.ERROR_PROC_NOT_FOUND:       detail = "ERROR_PROC_NOT_FOUND";             break;
      case WGL.ERROR_INVALID_WINDOW_HANDLE:detail = "ERROR_INVALID_WINDOW_HANDLE";      break;
      default:                             detail = "(Unknown error code " + err + ")"; break;
    }
    return detail;
  }
}