1package browser
2
3import (
4 "context"
5 "fmt"
6 "log"
7 "os"
8 "path/filepath"
9 "strings"
10 "time"
11
12 "github.com/bnema/dumber/internal/app/constants"
13 "github.com/bnema/dumber/internal/app/control"
14 "github.com/bnema/dumber/internal/app/environment"
15 "github.com/bnema/dumber/internal/app/messaging"
16 "github.com/bnema/dumber/internal/config"
17 "github.com/bnema/dumber/internal/filtering"
18 "github.com/bnema/dumber/pkg/webkit"
19)
20
21// buildMemoryConfig converts config.WebkitMemoryConfig to webkit.MemoryConfig
22func buildMemoryConfig(cfg config.WebkitMemoryConfig) webkit.MemoryConfig {
23 mc := webkit.MemoryConfig{
24 MemoryLimitMB: cfg.MemoryLimitMB,
25 ConservativeThreshold: cfg.ConservativeThreshold,
26 StrictThreshold: cfg.StrictThreshold,
27 KillThreshold: cfg.KillThreshold,
28 PollIntervalSeconds: cfg.PollIntervalSeconds,
29 EnableGCInterval: cfg.EnableGCInterval,
30 ProcessRecycleThreshold: cfg.ProcessRecycleThreshold,
31 EnablePageCache: cfg.EnablePageCache,
32 EnableMemoryMonitoring: cfg.EnableMemoryMonitoring,
33 }
34
35 // Convert string cache model to webkit constant
36 switch strings.ToLower(cfg.CacheModel) {
37 case "document_viewer", "documentviewer", "doc":
38 mc.CacheModel = webkit.CacheModelDocumentViewer
39 case "primary_web_browser", "primary", "primarywebbrowser":
40 mc.CacheModel = webkit.CacheModelPrimaryWebBrowser
41 default:
42 mc.CacheModel = webkit.CacheModelWebBrowser
43 }
44
45 return mc
46}
47
48func (app *BrowserApp) buildWebkitConfig() (*webkit.Config, error) {
49 dataDir, err := config.GetDataDir()
50 if err != nil {
51 return nil, err
52 }
53 stateDir, err := config.GetStateDir()
54 if err != nil {
55 return nil, err
56 }
57
58 webkitData := filepath.Join(dataDir, "webkit")
59 webkitCache := filepath.Join(stateDir, "webkit-cache")
60 if err := os.MkdirAll(webkitData, constants.DirPerm); err != nil {
61 return nil, err
62 }
63 if err := os.MkdirAll(webkitCache, constants.DirPerm); err != nil {
64 return nil, err
65 }
66
67 cfg := &webkit.Config{
68 Assets: app.assets,
69 InitialURL: "dumb://homepage",
70 ZoomDefault: 1.0,
71 EnableDeveloperExtras: true,
72 DataDir: webkitData,
73 CacheDir: webkitCache,
74 APIToken: app.config.APISecurity.Token,
75 DefaultSansFont: app.config.Appearance.SansFont,
76 DefaultSerifFont: app.config.Appearance.SerifFont,
77 DefaultMonospaceFont: app.config.Appearance.MonospaceFont,
78 DefaultFontSize: app.config.Appearance.DefaultFontSize,
79 Rendering: webkit.RenderingConfig{Mode: string(app.config.RenderingMode)},
80 UseDomZoom: app.config.UseDomZoom,
81 VideoAcceleration: webkit.VideoAccelerationConfig{
82 EnableVAAPI: app.config.VideoAcceleration.EnableVAAPI,
83 AutoDetectGPU: app.config.VideoAcceleration.AutoDetectGPU,
84 VAAPIDriverName: app.config.VideoAcceleration.VAAPIDriverName,
85 EnableAllDrivers: app.config.VideoAcceleration.EnableAllDrivers,
86 LegacyVAAPI: app.config.VideoAcceleration.LegacyVAAPI,
87 },
88 Memory: buildMemoryConfig(app.config.WebkitMemory),
89 CodecPreferences: webkit.CodecPreferencesConfig{
90 PreferredCodecs: strings.Split(app.config.CodecPreferences.PreferredCodecs, ","),
91 BlockedCodecs: environment.BuildBlockedCodecsList(app.config.CodecPreferences),
92 ForceAV1: app.config.CodecPreferences.ForceAV1,
93 CustomUserAgent: app.config.CodecPreferences.CustomUserAgent,
94 DisableTwitchCodecControl: app.config.CodecPreferences.DisableTwitchCodecControl,
95 },
96 }
97
98 return cfg, nil
99}
100
101func (app *BrowserApp) buildPane(view *webkit.WebView) (*BrowserPane, error) {
102 pane := &BrowserPane{
103 webView: view,
104 }
105
106 pane.clipboardController = control.NewClipboardController(view)
107 pane.zoomController = control.NewZoomController(app.browserService, view)
108 pane.navigationController = control.NewNavigationController(
109 app.parserService,
110 app.browserService,
111 view,
112 pane.zoomController,
113 )
114 pane.messageHandler = messaging.NewHandler(app.parserService, app.browserService)
115 pane.messageHandler.SetWebView(view)
116 pane.messageHandler.SetNavigationController(pane.navigationController)
117 pane.shortcutHandler = NewShortcutHandler(view, pane.clipboardController, app.config, app)
118
119 pane.zoomController.RegisterHandlers()
120 pane.shortcutHandler.RegisterShortcuts()
121
122 // Register navigation handler for workspace focus events if workspace exists
123 if app.workspace != nil {
124 app.workspace.RegisterNavigationHandler(view)
125 }
126
127 return pane, nil
128}
129
130func (app *BrowserApp) createPaneForView(view *webkit.WebView) (*BrowserPane, error) {
131 pane, err := app.buildPane(view)
132 if err != nil {
133 return nil, err
134 }
135
136 // Generate unique pane ID
137 pane.SetID(fmt.Sprintf("pane-%d-%p", time.Now().Unix(), view))
138 pane.initializeGUITracking()
139
140 // GUI manager will be loaded on-demand when needed
141 log.Printf("[webview] Created pane for webview: %s", view.ID())
142
143 app.attachPaneHandlers(pane)
144 return pane, nil
145}
146
147func (app *BrowserApp) attachPaneHandlers(pane *BrowserPane) {
148 if pane == nil || pane.webView == nil {
149 return
150 }
151
152 pane.webView.RegisterTitleChangedHandler(func(title string) {
153 if title == "" {
154 return
155 }
156 url := pane.webView.GetCurrentURL()
157 if url == "" {
158 return
159 }
160 go func(url, title string) {
161 ctx := context.Background()
162 if err := app.browserService.UpdatePageTitle(ctx, url, title); err != nil {
163 log.Printf("Warning: failed to update page title: %v", err)
164 }
165 }(url, title)
166 })
167
168 pane.webView.RegisterScriptMessageHandler(func(payload string) {
169 if app.workspace != nil {
170 app.workspace.focusByView(pane.webView)
171 }
172 pane.messageHandler.Handle(payload)
173 })
174
175 if pane.messageHandler != nil && pane.navigationController != nil {
176 pane.messageHandler.SetNavigationController(pane.navigationController)
177 }
178
179 pane.webView.RegisterPopupHandler(func(uri string) *webkit.WebView {
180 if app.workspace != nil {
181 return app.workspace.HandlePopup(pane.webView, uri)
182 }
183
184 // No workspace manager - just navigate in current pane
185 if uri != "" && pane.navigationController != nil {
186 go func() {
187 if err := pane.navigationController.NavigateToURL(uri); err != nil {
188 log.Printf("[webview] failed to navigate to URL %s: %v", uri, err)
189 }
190 }()
191 }
192 return nil
193 })
194}
195
196// createWebView creates and configures the WebView
197func (app *BrowserApp) createWebView() error {
198 log.Printf("Creating WebView (native backend expected: %v)", webkit.IsNativeAvailable())
199
200 cfg, err := app.buildWebkitConfig()
201 if err != nil {
202 return err
203 }
204
205 // Main window needs a top-level window
206 cfg.CreateWindow = true
207
208 view, err := webkit.NewWebView(cfg)
209
210 if err != nil {
211 return err
212 }
213
214 pane, err := app.createPaneForView(view)
215 if err != nil {
216 return err
217 }
218
219 app.webView = view
220 app.zoomController = pane.zoomController
221 app.navigationController = pane.navigationController
222 app.clipboardController = pane.clipboardController
223 app.messageHandler = pane.messageHandler
224 app.shortcutHandler = pane.shortcutHandler
225 app.panes = []*BrowserPane{pane}
226 app.activePane = pane
227
228 if app.workspace == nil {
229 app.workspace = NewWorkspaceManager(app, pane)
230 }
231
232 // Initialize window-level global shortcuts AFTER workspace is set up
233 if window := view.Window(); window != nil {
234 app.windowShortcutHandler = NewWindowShortcutHandler(window, app)
235 if app.windowShortcutHandler != nil {
236 log.Printf("Window-level global shortcuts initialized")
237 } else {
238 log.Printf("Warning: failed to initialize window-level shortcuts")
239 }
240 }
241
242 app.setupWebViewIntegration()
243
244 // Apply initial zoom and show window
245 app.zoomController.ApplyInitialZoom()
246
247 log.Printf("Showing WebView window…")
248 if err := view.Show(); err != nil {
249 log.Printf("Warning: failed to show WebView: %v", err)
250 } else if !webkit.IsNativeAvailable() {
251 log.Printf("Notice: running without webkit_cgo tag — no native window will be displayed.")
252 }
253
254 return nil
255}
256
257// setupWebViewIntegration connects the WebView to browser services
258func (app *BrowserApp) setupWebViewIntegration() {
259 app.browserService.AttachWebView(app.webView)
260
261 // GUI bundle is loaded via WebKit user scripts in enableUserContentManager
262 // No need to load separately in browser service
263
264 // Use native window as title updater
265 if win := app.webView.Window(); win != nil {
266 app.browserService.SetWindowTitleUpdater(win)
267 }
268}
269
270// setupContentBlocking initializes the content blocking system with proper timing
271func (app *BrowserApp) setupContentBlocking() error {
272 log.Printf("Initializing content blocking system...")
273
274 // Enable WebKit debug logging if requested
275 webkit.SetupWebKitDebugLogging(app.config)
276
277 defer func() {
278 if r := recover(); r != nil {
279 log.Printf("Content blocking setup panic recovered: %v", r)
280 }
281 }()
282
283 // Setup filter system
284 filterManager, err := filtering.SetupFilterSystem()
285 if err != nil {
286 log.Printf("Warning: Failed to setup filter system: %v", err)
287 return nil // Don't fail browser startup, continue without filters
288 }
289
290 // Store reference to filter manager
291 app.filterManager = filterManager
292
293 // Set up callback to re-apply network filters when they become ready
294 // This callback will be called from the async filter loading process
295 filterManager.SetFiltersReadyCallback(func() {
296 // Add small delay to avoid race conditions with WebView initialization
297 go func() {
298 time.Sleep(300 * time.Millisecond)
299 if app.webView != nil {
300 if err := app.webView.UpdateContentFilters(filterManager); err != nil {
301 log.Printf("Failed to apply filters after loading: %v", err)
302 } else {
303 log.Printf("Successfully applied filters after async loading")
304 }
305 }
306 }()
307 })
308
309 // Start async filter loading early (before WebView content blocking initialization)
310 // This allows filters to be ready when the WebView needs them
311 go func() {
312 if err := filtering.InitializeFiltersAsync(filterManager); err != nil {
313 log.Printf("Warning: failed to initialize filters asynchronously: %v", err)
314 }
315 }()
316
317 // Initialize content blocking in WebView with delay
318 // Wait for WebView to be fully loaded before setting up content blocking
319 go func() {
320 // Wait extra time for the first navigation to avoid preconnect interference
321 log.Printf("Waiting for WebView to complete initial load before enabling content blocking...")
322 time.Sleep(3000 * time.Millisecond) // 3 seconds for first load stability
323
324 if err := app.webView.InitializeContentBlocking(filterManager); err != nil {
325 log.Printf("Warning: Failed to initialize content blocking: %v", err)
326 // Continue without content blocking rather than failing
327 }
328
329 // Register navigation handler for domain-specific filtering and GUI injection
330 // Only register after content blocking is initialized
331 app.webView.RegisterURIChangedHandler(func(uri string) {
332 // Add small delay to avoid conflicts with page load
333 go func() {
334 time.Sleep(200 * time.Millisecond) // Slightly longer delay for stability
335
336 // Apply content filtering if available
337 if app.filterManager != nil {
338 app.webView.OnNavigate(uri, app.filterManager)
339 }
340
341 // Note: GUI bundle (controls and toast) is now injected as User Script
342 // in WebKit's enableUserContentManager, so it persists across all navigations
343 }()
344 })
345 }()
346
347 log.Printf("Content blocking system initialization started")
348 return nil
349}