#ifndef __CEF3WEBVWNDHANDLER_H_
#define __CEF3WEBVWNDHANDLER_H_

#include "include/cef_client.h"
#include "include/cef_app.h"
#include "include/cef_browser.h"
#include "include/cef_frame.h"
#include "Cef3ClientApp.h"
#include "include/cef_drag_handler.h"
#include "include/wrapper/cef_resource_manager.h"
 
#include <list>
#include "souistd.h"


namespace browser
{  

//const int POPUP_DEVTOOLS_WND = WM_APP + 2;

#define  WM_OPENFILEDIALOG   WM_USER+1880 
#define  WM_WEBURLDIALOG     WM_USER+1881

class   CCef3WebVWndHandler : public CefClient,
                       public CefRenderHandler,
                       public CefContextMenuHandler,
                       public CefDisplayHandler,
					   public CefDownloadHandler,
                       public CefDragHandler,
                       public CefKeyboardHandler,
                       public CefLifeSpanHandler,
					   public CefLoadHandler,
					   public CefDialogHandler,
					   public CefRequestHandler
{
public: 
	
	CCef3WebVWndHandler();
    ~CCef3WebVWndHandler();

// ------------------------------------------------------------------------------
// 
// browser methods for user
//
// ------------------------------------------------------------------------------

    IMPLEMENT_REFCOUNTING(CCef3WebVWndHandler);

public:
	void CloseDevTools(CefRefPtr<CefBrowser> browser); 
	 
    bool CreatePopupWindow(
		CefRefPtr<CefBrowser> browser,
		bool is_devtools,
		const CefPopupFeatures& popupFeatures,
		CefWindowInfo& windowInfo,
		CefRefPtr<CefClient>& client,
		CefBrowserSettings& settings);
	 

    BOOL Open(HWND hParent,const CefString& url,SOUI::CRect rcView);
    void Close();
    void CloseAllBrowsers(bool force_close);
    void OpenDevTools(); 	 
    CefRefPtr<CefBrowser> GetBrowser(); 

// ------------------------------------------------------------------------------
//
// impl cef handler callbacks
//
// ------------------------------------------------------------------------------

protected:

    //
    // CefClient methods. Important to return |this| for the handler callbacks.
    // 

    virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() OVERRIDE { return this; }
    virtual CefRefPtr<CefRenderHandler> GetRenderHandler()           OVERRIDE { return this; }
    virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler()         OVERRIDE { return this; }
    virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler()       OVERRIDE { return this; }
    virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler()       OVERRIDE { return this; }
    virtual CefRefPtr<CefLoadHandler> GetLoadHandler()               OVERRIDE { return this; }
    virtual CefRefPtr<CefDragHandler> GetDragHandler()               OVERRIDE { return this; }
	virtual CefRefPtr<CefRequestHandler> GetRequestHandler()         OVERRIDE { return this; }

    virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
        CefProcessId source_process,
        CefRefPtr<CefProcessMessage> message)  OVERRIDE 
    {
       

        return true;
    }

	// CefRequestHandler methods
	bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		CefRefPtr<CefRequest> request,
		bool is_redirect) ;//OVERRIDE;
	bool OnOpenURLFromTab(
		CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		const CefString& target_url,
		CefRequestHandler::WindowOpenDisposition target_disposition,
		bool user_gesture) OVERRIDE;
	cef_return_value_t OnBeforeResourceLoad(
		CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		CefRefPtr<CefRequest> request,
		CefRefPtr<CefRequestCallback> callback) OVERRIDE;
	CefRefPtr<CefResourceHandler> GetResourceHandler(
		CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		CefRefPtr<CefRequest> request) OVERRIDE;
	CefRefPtr<CefResponseFilter> GetResourceResponseFilter(
		CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		CefRefPtr<CefRequest> request,
		CefRefPtr<CefResponse> response) OVERRIDE;
	bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,
		const CefString& origin_url,
		int64 new_size,
		CefRefPtr<CefRequestCallback> callback) OVERRIDE;
	void OnProtocolExecution(CefRefPtr<CefBrowser> browser,
		const CefString& url,
		bool& allow_os_execution) OVERRIDE;
	bool OnCertificateError(
		CefRefPtr<CefBrowser> browser,
		ErrorCode cert_error,
		const CefString& request_url,
		CefRefPtr<CefSSLInfo> ssl_info,
		CefRefPtr<CefRequestCallback> callback) OVERRIDE;
	void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
		TerminationStatus status) OVERRIDE;

	 
    // CefRenderHandler interfaces 
    virtual bool GetRootScreenRect(CefRefPtr<CefBrowser> browser,
		CefRect& rect) OVERRIDE;
	virtual bool GetViewRect(CefRefPtr<CefBrowser> browser,
		CefRect& rect) OVERRIDE;
	virtual bool GetScreenPoint(CefRefPtr<CefBrowser> browser,
		int viewX,
		int viewY,
		int& screenX,
		int& screenY) OVERRIDE;
	virtual bool GetScreenInfo(CefRefPtr<CefBrowser> browser,
		CefScreenInfo& screen_info)  OVERRIDE;
    virtual void OnPopupShow(CefRefPtr<CefBrowser> browser,
        bool show) OVERRIDE; 
    virtual void OnPopupSize(CefRefPtr<CefBrowser> browser,
        const CefRect& rect)  OVERRIDE; 
    virtual void OnPaint(
        CefRefPtr<CefBrowser> browser,
        PaintElementType type,
        const RectList& dirtyRects,
        const void* buffer,
        int width,
        int height) OVERRIDE; 
	virtual void OnCursorChange(CefRefPtr<CefBrowser> browser,
		CefCursorHandle cursor,
		CursorType type,
		const CefCursorInfo& custom_cursor_info) OVERRIDE; 
    virtual bool StartDragging(
        CefRefPtr<CefBrowser> browser,
        CefRefPtr<CefDragData> drag_data,
        CefRenderHandler::DragOperationsMask allowed_ops,
        int x, int y) OVERRIDE; 
    virtual void UpdateDragCursor(
        CefRefPtr<CefBrowser> browser,
        CefRenderHandler::DragOperation operation)
        OVERRIDE;
	 void OnImeCompositionRangeChanged(
      CefRefPtr<CefBrowser> browser,
      const CefRange& selection_range,
      const CefRenderHandler::RectList& character_bounds) OVERRIDE;

    //
    // CefContextMenuHandler methods
    // 
	virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		CefRefPtr<CefContextMenuParams> params,
		CefRefPtr<CefMenuModel> model) OVERRIDE;

	// CefDisplayHandler methods
	void OnTitleChange(CefRefPtr<CefBrowser> browser,
					   const CefString& title) OVERRIDE;

	bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
						  const CefString& message,
						  const CefString& source, int line) OVERRIDE;
	void OnAddressChange(CefRefPtr<CefBrowser> browser,
						 CefRefPtr<CefFrame> frame,
						 const CefString& url) OVERRIDE;


    //
    // CefKeyboardHandler methods
    //
    virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
        const CefKeyEvent& event,
        CefEventHandle os_event,
        bool* is_keyboard_shortcut) OVERRIDE;

    //
    // CefLifeSpanHandler methods
    //
	virtual bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
		CefRefPtr<CefFrame> frame,
		const CefString& target_url,
		const CefString& target_frame_name,
		CefLifeSpanHandler::WindowOpenDisposition target_disposition,
		bool user_gesture,
		const CefPopupFeatures& popupFeatures,
		CefWindowInfo& windowInfo,
		CefRefPtr<CefClient>& client,
		CefBrowserSettings& settings,
		bool* no_javascript_access);//OVERRIDE;

    virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE ;
    virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
    virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser)OVERRIDE;

  /////////////////////////////////////CefDownloadHandler//////////////////////////////
  virtual void OnBeforeDownload(
      CefRefPtr<CefBrowser> browser,
      CefRefPtr<CefDownloadItem> download_item,
      const CefString& suggested_name,
      CefRefPtr<CefBeforeDownloadCallback> callback);
 
  
  virtual void OnDownloadUpdated(
      CefRefPtr<CefBrowser> browser,
      CefRefPtr<CefDownloadItem> download_item,
      CefRefPtr<CefDownloadItemCallback> callback); 

  virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() override;  
  /////////////////////////////////////end CefDownloadHandler//////////////////////////////

    //
    // CefLoadHandler methods
    //

    virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,
							 CefRefPtr<CefFrame> frame,
							 TransitionType transition_typ) OVERRIDE
    {
    }

    virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
        CefRefPtr<CefFrame> frame,
        int httpStatusCode) OVERRIDE
    {
        m_bPageLoaded = TRUE;
	 
    }

    virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
        CefRefPtr<CefFrame> frame,
        ErrorCode errorCode,
        const CefString& errorText,
        const CefString& failedUrl)
    {
		 CEF_REQUIRE_UI_THREAD();

		// Don't display an error for downloaded files.
		if (errorCode == ERR_ABORTED)
			return;

		// Display a load error message.
		std::stringstream ss;
		ss << "<html><body bgcolor=\"white\">"
			"<h2>Failed to load URL " << std::string(failedUrl) <<
			" with error " << std::string(errorText) << " (" << errorCode <<
			").</h2></body></html>";
		frame->LoadString(ss.str(), failedUrl);
    }

protected: 
		  ///
  // Return the handler for dialogs. If no handler is provided the default
  // implementation will be used.
  ///
  /*--cef()--*/
  virtual CefRefPtr<CefDialogHandler> GetDialogHandler() {
		return this;
  }

   virtual bool OnFileDialog(CefRefPtr<CefBrowser> browser,
                            FileDialogMode mode,
                            const CefString& title,
                            const CefString& default_file_path,
                            const std::vector<CefString>& accept_filters,
                            int selected_accept_filter,
                            CefRefPtr<CefFileDialogCallback> callback) {
	  
	m_pFileDialogCallback  = callback; 
	
	::SetFocus(m_hOwnerWnd); 
	 
	::SendMessage(m_hOwnerWnd,WM_OPENFILEDIALOG,NULL,NULL);
	 
	CefRefPtr<CefBrowserHost> host = browser->GetHost();
	host->SetFocus(true); 

    return true;
  }
public:
	CefRefPtr<CefFileDialogCallback> m_pFileDialogCallback;
private:
	mutable base::Lock lock_;	
	HWND    m_hOwnerWnd;
    CefRefPtr<CefBrowser>   m_refBrowser;
    BOOL                    m_bPageLoaded;
  
	CefRefPtr<CefClient>    m_refDevToolsClient;
	// Manages the registration and delivery of resources.
	CefRefPtr<CefResourceManager> resource_manager_;

	// Console logging state.
	const std::string console_log_file_;

	bool first_console_message_;

	std::wstring           m_PopupUrl; // µ¯³öµØÖ·
	std::wstring           m_strHtml; // ÒªÏÔʾµÄhtmlÄÚÈÝ
public:
	std::wstring          GetPopupUrl();
	bool				IsAllowOsExce(const CefString& url);// Allow OS execution of Spotify URIs.
	void				LoadHtml( std::wstring strValue);
};


} //namespace browser

#endif  // __CEF3WEBVWNDHANDLER_H_