package cef

import (
	"context"
	"fmt"
	"strings"
	"sync"

	"github.com/bnema/dumber/internal/infrastructure/webutil"

	"github.com/bnema/dumber/internal/application/port"
	"github.com/bnema/dumber/internal/logging"
)

// Compile-time interface check.
var _ port.ContentInjector = (*contentInjector)(nil)

// scrollbarCSS styles the scrollbar with auto-hide behavior: invisible by
// default, fades in on scroll, widens on hover, fades out after 1s idle.
// Uses --primary theme color for the thumb.
const scrollbarCSS = `
::-webkit-scrollbar {
  width: 6px;
  height: 6px;
}
::-webkit-scrollbar-track {
  background: transparent;
}
::-webkit-scrollbar-thumb {
  background: transparent;
  border-radius: 3px;
}
.dumber-scrolling ::-webkit-scrollbar-thumb {
  background: var(--primary, rgba(128, 128, 128, 0.4));
}
.dumber-scrolling ::-webkit-scrollbar:hover {
  width: 10px;
  height: 10px;
}
.dumber-scrolling ::-webkit-scrollbar-track:hover {
  background: rgba(128, 128, 128, 0.1);
}
.dumber-scrolling ::-webkit-scrollbar-thumb:hover {
  background: var(--primary, rgba(128, 128, 128, 0.6));
}
::-webkit-scrollbar-corner {
  background: transparent;
}
`

// scrollbarAutoHideJS adds/removes the .dumber-scrolling class on <html>
// on scroll activity, with a 1s fade-out timeout after scrolling stops.
const scrollbarAutoHideJS = `(function(){
  var t, el = document.documentElement;
  function show() {
    el.classList.add('dumber-scrolling');
    clearTimeout(t);
    t = setTimeout(function(){ el.classList.remove('dumber-scrolling'); }, 1000);
  }
  window.addEventListener('scroll', show, {passive:true,capture:true});
  window.addEventListener('wheel', show, {passive:true});
  el.addEventListener('mouseenter', function(){
    if(el.scrollHeight > el.clientHeight) show();
  });
})();`

// videoDiagnosticJS monitors all <video> elements on the page and logs their
// state changes to the console. This helps diagnose playback issues in CEF OSR.
// TODO: remove once video playback is stable.
const videoDiagnosticJS = `(function(){
  var tag = '[VIDEO-DIAG]';
  var events = ['loadstart','loadedmetadata','loadeddata','canplay','canplaythrough',
    'play','playing','pause','waiting','stalled','error','abort','emptied','suspend'];

  function monitor(v, label) {
    if (v._dumberDiag) return;
    v._dumberDiag = true;
    console.warn(tag, label, 'src:', (v.src||'').substring(0,80),
      'currentSrc:', (v.currentSrc||'').substring(0,80),
      'readyState:', v.readyState, 'networkState:', v.networkState,
      'preload:', v.preload, 'autoplay:', v.autoplay);
    events.forEach(function(evt) {
      v.addEventListener(evt, function() {
        var err = v.error ? ('code='+v.error.code+' msg='+v.error.message) : 'none';
        console.warn(tag, evt, label, 'ready:', v.readyState, 'net:', v.networkState,
          'paused:', v.paused, 'error:', err, 'src:', (v.currentSrc||v.src||'').substring(0,80));
      });
    });
  }

  // Recursively scan a root (document or shadowRoot) for video elements.
  function scanRoot(root, label) {
    root.querySelectorAll('video').forEach(function(v, i) { monitor(v, label+'#'+i); });
    // Pierce shadow DOMs.
    root.querySelectorAll('*').forEach(function(el) {
      if (el.shadowRoot) {
        scanRoot(el.shadowRoot, label+'>'+el.tagName.toLowerCase());
        // Observe inside shadow root too.
        observeRoot(el.shadowRoot, label+'>'+el.tagName.toLowerCase());
      }
    });
  }

  function observeRoot(root, label) {
    new MutationObserver(function(muts) {
      muts.forEach(function(m) {
        m.addedNodes.forEach(function(n) {
          if (n.nodeName === 'VIDEO') monitor(n, label+'-dyn');
          if (n.querySelectorAll) {
            n.querySelectorAll('video').forEach(function(v) { monitor(v, label+'-nested'); });
          }
          // New element might have shadow root.
          if (n.shadowRoot) {
            scanRoot(n.shadowRoot, label+'>'+n.tagName.toLowerCase());
            observeRoot(n.shadowRoot, label+'>'+n.tagName.toLowerCase());
          }
        });
      });
    }).observe(root, {childList:true, subtree:true});
  }

  // Patch attachShadow to automatically observe new shadow roots.
  // Use a marker to avoid double-patching.
  var origAttach = Element.prototype.__dumberOrigAttachShadow || Element.prototype.attachShadow;
  if (!Element.prototype.__dumberPatched) {
    Element.prototype.__dumberOrigAttachShadow = origAttach;
    Element.prototype.__dumberPatched = true;
  }
  Element.prototype.attachShadow = function(opts) {
    var sr = origAttach.call(this, opts);
    console.warn(tag, 'shadowRoot attached on', this.tagName.toLowerCase());
    observeRoot(sr, 'shadow>'+this.tagName.toLowerCase());
    return sr;
  };

  // Also intercept MediaSource to trace usage.
  if (window.MediaSource) {
    var origAddSB = MediaSource.prototype.addSourceBuffer;
    MediaSource.prototype.addSourceBuffer = function(mime) {
      console.warn(tag, 'MediaSource.addSourceBuffer:', mime,
        'supported:', MediaSource.isTypeSupported(mime));
      try { return origAddSB.call(this, mime); }
      catch(e) { console.error(tag, 'addSourceBuffer FAILED:', e.message, 'mime:', mime); throw e; }
    };
    var origURL = URL.createObjectURL;
    URL.createObjectURL = function(obj) {
      var url = origURL.call(this, obj);
      if (obj instanceof MediaSource) {
        console.warn(tag, 'URL.createObjectURL(MediaSource):', url.substring(0,80));
      }
      return url;
    };
  }

  // Initial scan.
  scanRoot(document, 'doc');

  // Observe document for new elements.
  observeRoot(document.documentElement, 'doc');

  console.warn(tag, 'diagnostic active, MSE:', !!window.MediaSource,
    'h264:', MediaSource ? MediaSource.isTypeSupported('video/mp4; codecs="avc1.4d401e"') : 'n/a',
    'aac:', MediaSource ? MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.2"') : 'n/a');
})();`

// contentInjector implements port.ContentInjector for the CEF engine.
// It stores CSS strings and injects them into webviews via ExecuteJavaScript.
// Thread-safe: InjectThemeCSS may be called from the UI thread while OnLoadEnd
// fires on the CEF IO thread.
type contentInjector struct {
	mu                      sync.RWMutex
	themeCSS                string
	findHighlightCSS        string
	engine                  *Engine
	colorResolver           port.ColorSchemeResolver
	videoDiagnosticsEnabled bool
}

// setColorResolver updates the color scheme resolver used for dark mode detection.
func (ci *contentInjector) setColorResolver(resolver port.ColorSchemeResolver) {
	ci.mu.Lock()
	defer ci.mu.Unlock()
	ci.colorResolver = resolver
}

// newContentInjector creates a content injector wired to the given engine.
// Video diagnostics are enabled when DUMBER_VIDEO_DIAG=1 is set.
func newContentInjector(engine *Engine, resolver port.ColorSchemeResolver) *contentInjector {
	diagEnabled := envBoolEnabled("DUMBER_VIDEO_DIAG")
	return &contentInjector{
		engine:                  engine,
		colorResolver:           resolver,
		videoDiagnosticsEnabled: diagEnabled,
	}
}

// InjectThemeCSS stores the theme CSS and broadcasts it to all active webviews.
func (ci *contentInjector) InjectThemeCSS(ctx context.Context, css string) error {
	log := logging.FromContext(ctx).With().Str("component", "cef-content-injector").Logger()

	ci.mu.Lock()
	ci.themeCSS = css
	ci.mu.Unlock()

	log.Debug().Int("css_len", len(css)).Msg("theme CSS set, broadcasting to active webviews")

	// Broadcast to all active webviews.
	ci.engine.activeWebViews.Range(func(_, value any) bool {
		if wv, ok := value.(*WebView); ok {
			ci.injectCSS(wv, 0, "dumber-theme-vars", css)
		}
		return true
	})
	return nil
}

// InjectFindHighlightCSS stores the find highlight CSS and broadcasts it.
func (ci *contentInjector) InjectFindHighlightCSS(ctx context.Context, css string) error {
	log := logging.FromContext(ctx).With().Str("component", "cef-content-injector").Logger()

	ci.mu.Lock()
	ci.findHighlightCSS = css
	ci.mu.Unlock()

	log.Debug().Int("css_len", len(css)).Msg("find highlight CSS set, broadcasting to active webviews")

	ci.engine.activeWebViews.Range(func(_, value any) bool {
		if wv, ok := value.(*WebView); ok {
			ci.injectCSS(wv, 0, "dumber-find-highlight", css)
		}
		return true
	})
	return nil
}

// RefreshScripts re-injects all scripts into a specific webview.
func (ci *contentInjector) RefreshScripts(ctx context.Context, wv port.WebView) error {
	log := logging.FromContext(ctx).With().Str("component", "cef-content-injector").Logger()
	if wv == nil {
		log.Debug().Msg("RefreshScripts: nil webview")
		return nil
	}
	cefWV, ok := wv.(*WebView)
	if !ok {
		log.Debug().Msg("RefreshScripts: webview is not *cef.WebView")
		return nil
	}

	ci.onLoadEnd(cefWV, 0)
	return nil
}

// onLoadEndForEvent installs scripts for a captured load-end event after
// revalidating it on the GTK thread. The event identity comes from the
// OnLoadEnd callback's browser (not mutable WebView state), so events that
// are provably stale are skipped: a replaced browser identifier (old main
// frame during process swap) or a superseded intent ID (a newer navigation
// committed while the callback was queued). Ambiguous cases fall back to skipping rather than
// installing blind: an event captured without a browser cannot prove
// identity, and the current browser gets its own load-end installation.
// The installation is pinned to the validated document sequence, so a
// replacement commit between validation and the CEF UI thread drops the
// scripts instead of injecting them into the new document. Repeated
// notifications for the same committed document are coalesced.
func (ci *contentInjector) onLoadEndForEvent(wv *WebView, event injectionEvent) {
	if wv == nil || ci == nil || event.browserID == noBrowserID {
		return
	}
	wv.mu.RLock()
	browser := wv.browser
	wv.mu.RUnlock()
	if browser == nil || browser.GetIdentifier() != event.browserID {
		return
	}
	wv.mu.Lock()
	if wv.browser != browser || wv.pendingIntentID != event.intentID || event.documentSeq == 0 ||
		wv.documentSeq != event.documentSeq || strings.TrimSpace(wv.uri) != event.frameURL ||
		wv.installedDocumentSeq == event.documentSeq {
		wv.mu.Unlock()
		return
	}
	wv.installedDocumentSeq = event.documentSeq
	wv.mu.Unlock()
	ci.onLoadEnd(wv, event.documentSeq)
}

// onLoadEnd is called from the load handler after a page finishes loading.
// It injects the appropriate scripts based on whether the page is internal.
// A documentSeq of 0 installs unconditionally (manual refresh paths).
func (ci *contentInjector) onLoadEnd(wv *WebView, documentSeq uint64) {
	uri := wv.URI()
	isInternal := isConceptualInternalURL(uri) || isActualInternalURL(uri)

	ci.mu.RLock()
	themeCSS := ci.themeCSS
	findCSS := ci.findHighlightCSS
	ci.mu.RUnlock()

	// Internal pages get dark mode + message bridge + theme CSS.
	if isInternal {
		prefersDark := false
		if ci.colorResolver != nil {
			prefersDark = ci.colorResolver.Resolve().PrefersDark
		}
		ci.injectDarkModeScript(wv, documentSeq, prefersDark)
		ci.injectMessageBridgeShim(wv, documentSeq)
		if themeCSS != "" {
			ci.injectCSS(wv, documentSeq, "dumber-theme-vars", themeCSS)
		}
	}

	// All pages get find highlight CSS if set.
	if findCSS != "" {
		ci.injectCSS(wv, documentSeq, "dumber-find-highlight", findCSS)
	}

	// All pages get custom scrollbar styling with auto-hide.
	ci.injectCSS(wv, documentSeq, "dumber-scrollbar", scrollbarCSS)
	wv.RunJavaScriptForDocument(documentSeq, scrollbarAutoHideJS)

	// Clipboard copy/cut, editable focus sync, and synthetic popup proxies still
	// need a JS bridge in OSR mode while the native renderer bridge remains disabled.
	bridgeNonce := wv.ensureBridgeNonce()
	if bridgeNonce == "" {
		ctx := context.Background()
		if ci != nil && ci.engine != nil {
			ctx = ci.engine.currentContext()
		}
		logging.FromContext(ctx).Warn().Msg("cef: skipped clipboard bridge injection — nonce generation failed")
	} else {
		wv.RunJavaScriptForDocument(documentSeq, buildTrustedPageFetchBridgeJS(bridgeNonce))
	}

	// Video playback diagnostic — logs video element state changes.
	// Gated behind DUMBER_VIDEO_DIAG=1 environment variable.
	if ci.videoDiagnosticsEnabled {
		wv.RunJavaScriptForDocument(documentSeq, videoDiagnosticJS)
	}
}

// injectCSS injects a CSS string as a <style> element via JavaScript. The
// style is pinned to documentSeq when the caller knows the committed document
// sequence; 0 installs unconditionally.
func (ci *contentInjector) injectCSS(wv *WebView, documentSeq uint64, id, css string) {
	escapedID := webutil.EscapeForJSString(id)
	escaped := webutil.EscapeForJSString(css)
	script := fmt.Sprintf(`(function(){
  var el = document.getElementById('%s');
  if (!el) { el = document.createElement('style'); el.id = '%s'; document.head.appendChild(el); }
  el.textContent = '%s';
})();`, escapedID, escapedID, escaped)

	wv.RunJavaScriptForDocument(documentSeq, script)
}

// injectDarkModeScript sets dark/light class on <html> and patches matchMedia
// for prefers-color-scheme queries on internal pages.
func (ci *contentInjector) injectDarkModeScript(wv *WebView, documentSeq uint64, prefersDark bool) {
	wv.RunJavaScriptForDocument(documentSeq, webutil.DarkModeScript(prefersDark, "__dumber_cef_prefers_dark"))
}

// injectMessageBridgeShim injects the window.dumber.postMessage JS client shim
// so internal pages can communicate with Go handlers via fetch.
// The message body is base64-encoded into the X-Dumber-Body header to work
// around purego-cef's unexported PostData element wrapper.
func (ci *contentInjector) injectMessageBridgeShim(wv *WebView, documentSeq uint64) {
	wv.RunJavaScriptForDocument(documentSeq, MessageBridgeJS)
}