package handlers

import (
	"encoding/json"
	"fikoyt-ajan/internal/desktop"
	"fikoyt-ajan/internal/filemanager"
	"fikoyt-ajan/internal/plugin"
	"fikoyt-ajan/internal/processmanager"
	"fikoyt-ajan/internal/updater"
	"log"
	"sync"
)

// RemoteHandler - Uzak kontrol handler'ı
type RemoteHandler struct {
	mu              sync.RWMutex
	screenCapture   *desktop.ScreenCapture
	inputController *desktop.InputController
	fileManager     *filemanager.FileManager
	processManager  *processmanager.ProcessManager
	pluginManager   *plugin.PluginManager
	updater         *updater.Updater
	webrtcStreamer  *desktop.WebRTCStreamer

	// Callbacks
	onScreenFrame   func(frame *desktop.ScreenFrame)
	onEvent         func(event string, data interface{})
	onWebRTCICE     func(candidate interface{})
	onWebRTCSDP     func(sdp interface{})
}

// NewRemoteHandler - Yeni uzak kontrol handler
func NewRemoteHandler(pluginDir, configDir, currentVersion, updateURL string) *RemoteHandler {
	rh := &RemoteHandler{
		screenCapture:   desktop.NewScreenCapture(),
		inputController: desktop.NewInputController(),
		fileManager:     filemanager.NewFileManager(),
		processManager:  processmanager.NewProcessManager(),
		pluginManager:   plugin.NewPluginManager(pluginDir, configDir),
		updater:         updater.NewUpdater(currentVersion, updateURL),
	}

	return rh
}

// SetCallbacks - Callback'leri ayarla
func (rh *RemoteHandler) SetCallbacks(onFrame func(*desktop.ScreenFrame), onEvent func(string, interface{})) {
	rh.mu.Lock()
	defer rh.mu.Unlock()
	rh.onScreenFrame = onFrame
	rh.onEvent = onEvent
}

// SetWebRTCCallbacks - WebRTC callback'lerini ayarla
func (rh *RemoteHandler) SetWebRTCCallbacks(onICE func(interface{}), onSDP func(interface{})) {
	rh.mu.Lock()
	defer rh.mu.Unlock()
	rh.onWebRTCICE = onICE
	rh.onWebRTCSDP = onSDP
}

// Start - Handler'ı başlat
func (rh *RemoteHandler) Start() {
	// Updater'ı başlat
	rh.updater.Start()

	// Plugin'leri keşfet ve yükle
	go func() {
		manifests, err := rh.pluginManager.DiscoverPlugins()
		if err != nil {
			log.Printf("Plugin keşfi hatası: %v", err)
			return
		}
		for _, manifest := range manifests {
			if err := rh.pluginManager.LoadPlugin(manifest.ID); err != nil {
				log.Printf("Plugin yükleme hatası: %s - %v", manifest.ID, err)
			}
		}
	}()
}

// Stop - Handler'ı durdur
func (rh *RemoteHandler) Stop() {
	rh.screenCapture.StopStreaming()
	rh.inputController.Disable()
	rh.updater.Stop()
}

// ============== SCREEN CAPTURE ==============

// HandleScreenCapture - Ekran görüntüsü yakala
func (rh *RemoteHandler) HandleScreenCapture(data map[string]interface{}) map[string]interface{} {
	log.Printf("📸 [HandleScreenCapture] İstek alındı: %+v", data)

	config := &desktop.ScreenCaptureConfig{
		Quality:   getIntOrDefault(data, "quality", 70),
		Scale:     getFloatOrDefault(data, "scale", 0.5),
		DisplayID: getIntOrDefault(data, "displayId", 0),
		Format:    getStringOrDefault(data, "format", "jpeg"),
	}

	log.Printf("📸 [HandleScreenCapture] Config: Quality=%d, Scale=%.2f, DisplayID=%d, Format=%s",
		config.Quality, config.Scale, config.DisplayID, config.Format)

	// Region varsa ekle
	if region, ok := data["region"].(map[string]interface{}); ok {
		config.Region = &desktop.Region{
			X:      getIntOrDefault(region, "x", 0),
			Y:      getIntOrDefault(region, "y", 0),
			Width:  getIntOrDefault(region, "width", 800),
			Height: getIntOrDefault(region, "height", 600),
		}
	}

	frame, err := rh.screenCapture.CaptureScreen(config)
	if err != nil {
		log.Printf("❌ [HandleScreenCapture] Hata: %v", err)
		return map[string]interface{}{
			"basarili": false,
			"hata":     err.Error(),
		}
	}

	log.Printf("✅ [HandleScreenCapture] Başarılı - Frame: %dx%d, Data uzunluğu: %d chars",
		frame.Width, frame.Height, len(frame.Data))

	// Frame'i doğrudan map olarak döndür (JSON serialization için daha güvenli)
	return map[string]interface{}{
		"basarili": true,
		"frame": map[string]interface{}{
			"data":      frame.Data,
			"width":     frame.Width,
			"height":    frame.Height,
			"timestamp": frame.Timestamp,
			"displayId": frame.DisplayID,
			"format":    frame.Format,
			"size":      frame.Size,
		},
	}
}

// HandleScreenStreamStart - Ekran streaming başlat
func (rh *RemoteHandler) HandleScreenStreamStart(data map[string]interface{}) map[string]interface{} {
	config := &desktop.ScreenCaptureConfig{
		Quality:   getIntOrDefault(data, "quality", 50),
		FPS:       getIntOrDefault(data, "fps", 10),
		Scale:     getFloatOrDefault(data, "scale", 0.4),
		DisplayID: getIntOrDefault(data, "displayId", 0),
	}

	err := rh.screenCapture.StartStreaming(config, func(frame *desktop.ScreenFrame) {
		if rh.onScreenFrame != nil {
			rh.onScreenFrame(frame)
		}
	})

	if err != nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     err.Error(),
		}
	}

	return map[string]interface{}{
		"basarili": true,
		"stats":    rh.screenCapture.GetStreamStats(),
	}
}

// HandleScreenStreamStop - Ekran streaming durdur
func (rh *RemoteHandler) HandleScreenStreamStop() map[string]interface{} {
	rh.screenCapture.StopStreaming()
	return map[string]interface{}{
		"basarili": true,
	}
}

// HandleScreenStreamConfig - Ekran streaming ayarlarını güncelle
func (rh *RemoteHandler) HandleScreenStreamConfig(data map[string]interface{}) map[string]interface{} {
	config := &desktop.ScreenCaptureConfig{
		Quality:   getIntOrDefault(data, "quality", 0),
		FPS:       getIntOrDefault(data, "fps", 0),
		Scale:     getFloatOrDefault(data, "scale", 0),
		DisplayID: getIntOrDefault(data, "displayId", -1),
	}

	rh.screenCapture.UpdateConfig(config)

	return map[string]interface{}{
		"basarili": true,
		"stats":    rh.screenCapture.GetStreamStats(),
	}
}

// HandleGetDisplays - Ekranları listele
func (rh *RemoteHandler) HandleGetDisplays() map[string]interface{} {
	displays := rh.screenCapture.GetDisplays()
	return map[string]interface{}{
		"basarili": true,
		"displays": displays,
	}
}

// ============== WEBRTC STREAMING ==============

// HandleWebRTCStart - WebRTC streaming başlat (offer oluştur)
func (rh *RemoteHandler) HandleWebRTCStart(data map[string]interface{}) map[string]interface{} {
	// Mevcut WebRTC varsa durdur
	if rh.webrtcStreamer != nil {
		rh.webrtcStreamer.Stop()
	}

	config := &desktop.WebRTCConfig{
		Quality:       getIntOrDefault(data, "quality", 70),
		FPS:           getIntOrDefault(data, "fps", 30),
		Scale:         getFloatOrDefault(data, "scale", 0.7),
		DisplayID:     getIntOrDefault(data, "displayId", 0),
		UseDirtyRects: getBoolOrDefault(data, "useDirtyRects", true),
		Compression:   getBoolOrDefault(data, "compression", true),
	}

	// Yeni WebRTC streamer oluştur
	streamer := desktop.NewWebRTCStreamer(rh.screenCapture)

	// Callback'leri ayarla
	streamer.SetCallbacks(
		func(candidate string) {
			if rh.onWebRTCICE != nil {
				rh.onWebRTCICE(candidate)
			}
		},
		func(state string) {
			// Connection state callback
			if rh.onEvent != nil {
				rh.onEvent("webrtc.state", map[string]interface{}{"state": state})
			}
		},
		nil, // onData - panel'den gelen mesajlar için
	)

	rh.webrtcStreamer = streamer

	// Offer oluştur
	offer, err := streamer.CreateOffer(config)
	if err != nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     err.Error(),
		}
	}

	return map[string]interface{}{
		"basarili": true,
		"offer":    offer,
	}
}

// HandleWebRTCAnswer - WebRTC answer işle
func (rh *RemoteHandler) HandleWebRTCAnswer(data map[string]interface{}) map[string]interface{} {
	if rh.webrtcStreamer == nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     "WebRTC oturumu yok",
		}
	}

	sdp := getStringOrDefault(data, "sdp", "")
	if sdp == "" {
		return map[string]interface{}{
			"basarili": false,
			"hata":     "SDP gerekli",
		}
	}

	signal := &desktop.WebRTCSignal{
		Type: "answer",
		SDP:  sdp,
	}

	err := rh.webrtcStreamer.HandleAnswer(signal)
	if err != nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     err.Error(),
		}
	}

	return map[string]interface{}{
		"basarili": true,
	}
}

// HandleWebRTCOffer - Panel'den gelen offer işle (ajan answer gönderir)
func (rh *RemoteHandler) HandleWebRTCOffer(data map[string]interface{}) map[string]interface{} {
	// Mevcut WebRTC varsa durdur
	if rh.webrtcStreamer != nil {
		rh.webrtcStreamer.Stop()
	}

	config := &desktop.WebRTCConfig{
		Quality:       getIntOrDefault(data, "quality", 70),
		FPS:           getIntOrDefault(data, "fps", 30),
		Scale:         getFloatOrDefault(data, "scale", 0.7),
		DisplayID:     getIntOrDefault(data, "displayId", 0),
		UseDirtyRects: getBoolOrDefault(data, "useDirtyRects", true),
		Compression:   getBoolOrDefault(data, "compression", true),
	}

	// Yeni WebRTC streamer oluştur
	streamer := desktop.NewWebRTCStreamer(rh.screenCapture)

	// Callback'leri ayarla
	streamer.SetCallbacks(
		func(candidate string) {
			if rh.onWebRTCICE != nil {
				rh.onWebRTCICE(candidate)
			}
		},
		func(state string) {
			// Connection state callback
			if rh.onEvent != nil {
				rh.onEvent("webrtc.state", map[string]interface{}{"state": state})
			}
		},
		nil, // onData
	)

	rh.webrtcStreamer = streamer

	// Offer'ı işle ve answer oluştur
	sdp := getStringOrDefault(data, "sdp", "")
	if sdp == "" {
		return map[string]interface{}{
			"basarili": false,
			"hata":     "SDP gerekli",
		}
	}

	signal := &desktop.WebRTCSignal{
		Type: "offer",
		SDP:  sdp,
	}

	answer, err := streamer.HandleOffer(signal, config)
	if err != nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     err.Error(),
		}
	}

	return map[string]interface{}{
		"basarili": true,
		"answer":   answer,
	}
}

// HandleWebRTCICECandidate - ICE candidate ekle
func (rh *RemoteHandler) HandleWebRTCICECandidate(data map[string]interface{}) map[string]interface{} {
	if rh.webrtcStreamer == nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     "WebRTC oturumu yok",
		}
	}

	// Candidate JSON formatında gelir
	candidateJSON := getStringOrDefault(data, "candidate", "")
	if candidateJSON == "" {
		// Eğer ayrı alanlar geldiyse JSON'a çevir
		candidate := getStringOrDefault(data, "candidateStr", "")
		sdpMid := getStringOrDefault(data, "sdpMid", "")
		sdpMLineIndex := getIntOrDefault(data, "sdpMLineIndex", 0)

		candidateObj := map[string]interface{}{
			"candidate":     candidate,
			"sdpMid":        sdpMid,
			"sdpMLineIndex": sdpMLineIndex,
		}

		candidateBytes, _ := json.Marshal(candidateObj)
		candidateJSON = string(candidateBytes)
	}

	err := rh.webrtcStreamer.AddICECandidate(candidateJSON)
	if err != nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     err.Error(),
		}
	}

	return map[string]interface{}{
		"basarili": true,
	}
}

// HandleWebRTCStop - WebRTC streaming durdur
func (rh *RemoteHandler) HandleWebRTCStop() map[string]interface{} {
	if rh.webrtcStreamer != nil {
		rh.webrtcStreamer.Stop()
		rh.webrtcStreamer = nil
	}

	return map[string]interface{}{
		"basarili": true,
	}
}

// HandleWebRTCStats - WebRTC istatistikleri
func (rh *RemoteHandler) HandleWebRTCStats() map[string]interface{} {
	if rh.webrtcStreamer == nil {
		return map[string]interface{}{
			"basarili": false,
			"hata":     "WebRTC oturumu yok",
		}
	}

	return map[string]interface{}{
		"basarili": true,
		"stats":    rh.webrtcStreamer.GetStats(),
	}
}

// ============== INPUT CONTROL ==============

// HandleMouseMove - Mouse hareket
func (rh *RemoteHandler) HandleMouseMove(data map[string]interface{}) map[string]interface{} {
	x := getIntOrDefault(data, "x", 0)
	y := getIntOrDefault(data, "y", 0)
	relative := getBoolOrDefault(data, "relative", false)

	err := rh.inputController.MoveMouse(x, y, relative)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleMouseClick - Mouse tıklama
func (rh *RemoteHandler) HandleMouseClick(data map[string]interface{}) map[string]interface{} {
	button := getStringOrDefault(data, "button", "left")
	clicks := getIntOrDefault(data, "clicks", 1)
	x := getIntOrDefault(data, "x", -1)
	y := getIntOrDefault(data, "y", -1)

	err := rh.inputController.MouseClick(button, clicks, x, y)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleMouseDown - Mouse tuşu basılı
func (rh *RemoteHandler) HandleMouseDown(data map[string]interface{}) map[string]interface{} {
	button := getStringOrDefault(data, "button", "left")
	err := rh.inputController.MouseDown(button)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}
	return map[string]interface{}{"basarili": true}
}

// HandleMouseUp - Mouse tuşu bırakıldı
func (rh *RemoteHandler) HandleMouseUp(data map[string]interface{}) map[string]interface{} {
	button := getStringOrDefault(data, "button", "left")
	err := rh.inputController.MouseUp(button)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}
	return map[string]interface{}{"basarili": true}
}

// HandleMouseScroll - Mouse scroll
func (rh *RemoteHandler) HandleMouseScroll(data map[string]interface{}) map[string]interface{} {
	deltaX := getIntOrDefault(data, "deltaX", 0)
	deltaY := getIntOrDefault(data, "deltaY", 0)

	err := rh.inputController.MouseScroll(deltaX, deltaY)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleKeyPress - Tuş basma
func (rh *RemoteHandler) HandleKeyPress(data map[string]interface{}) map[string]interface{} {
	event := desktop.KeyboardEvent{
		Key:     getStringOrDefault(data, "key", ""),
		Code:    getStringOrDefault(data, "code", ""),
		KeyCode: getIntOrDefault(data, "keyCode", 0),
		Char:    getStringOrDefault(data, "char", ""),
		Shift:   getBoolOrDefault(data, "shift", false),
		Ctrl:    getBoolOrDefault(data, "ctrl", false),
		Alt:     getBoolOrDefault(data, "alt", false),
		Meta:    getBoolOrDefault(data, "meta", false),
	}

	err := rh.inputController.KeyPress(event)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleKeyDown - Tuş basılı tutma
func (rh *RemoteHandler) HandleKeyDown(data map[string]interface{}) map[string]interface{} {
	event := desktop.KeyboardEvent{
		Key:     getStringOrDefault(data, "key", ""),
		Code:    getStringOrDefault(data, "code", ""),
		KeyCode: getIntOrDefault(data, "keyCode", 0),
	}

	err := rh.inputController.KeyDown(event)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleKeyUp - Tuş bırakma
func (rh *RemoteHandler) HandleKeyUp(data map[string]interface{}) map[string]interface{} {
	event := desktop.KeyboardEvent{
		Key:     getStringOrDefault(data, "key", ""),
		Code:    getStringOrDefault(data, "code", ""),
		KeyCode: getIntOrDefault(data, "keyCode", 0),
	}

	err := rh.inputController.KeyUp(event)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleTypeText - Metin yazma
func (rh *RemoteHandler) HandleTypeText(data map[string]interface{}) map[string]interface{} {
	text := getStringOrDefault(data, "text", "")
	delay := getIntOrDefault(data, "delay", 10)

	err := rh.inputController.TypeText(text, delay)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleKeyCombination - Tuş kombinasyonu
func (rh *RemoteHandler) HandleKeyCombination(data map[string]interface{}) map[string]interface{} {
	keysRaw, ok := data["keys"].([]interface{})
	if !ok {
		return map[string]interface{}{"basarili": false, "hata": "keys dizisi gerekli"}
	}

	keys := make([]string, len(keysRaw))
	for i, k := range keysRaw {
		keys[i] = k.(string)
	}

	err := rh.inputController.SendKeyCombination(keys)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleInputEnable - Input kontrolünü etkinleştir
func (rh *RemoteHandler) HandleInputEnable() map[string]interface{} {
	rh.inputController.Enable()
	return map[string]interface{}{"basarili": true}
}

// HandleInputDisable - Input kontrolünü devre dışı bırak
func (rh *RemoteHandler) HandleInputDisable() map[string]interface{} {
	rh.inputController.Disable()
	return map[string]interface{}{"basarili": true}
}

// ============== FILE MANAGER ==============

// HandleFileList - Klasör içeriğini listele
func (rh *RemoteHandler) HandleFileList(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	showHidden := getBoolOrDefault(data, "showHidden", false)
	sortBy := getStringOrDefault(data, "sortBy", "name")
	sortDesc := getBoolOrDefault(data, "sortDesc", false)

	contents, err := rh.fileManager.ListDirectory(path, showHidden, sortBy, sortDesc)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"contents": contents,
	}
}

// HandleFileGetDrives - Sürücüleri listele
func (rh *RemoteHandler) HandleFileGetDrives() map[string]interface{} {
	drives := rh.fileManager.GetDrives()
	return map[string]interface{}{
		"basarili": true,
		"drives":   drives,
	}
}

// HandleFileInfo - Dosya bilgisi
func (rh *RemoteHandler) HandleFileInfo(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")

	info, err := rh.fileManager.GetFileInfo(path)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"info":     info,
	}
}

// HandleFileCreate - Dosya/Klasör oluştur
func (rh *RemoteHandler) HandleFileCreate(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	isDir := getBoolOrDefault(data, "isDir", false)

	var err error
	if isDir {
		err = rh.fileManager.CreateDirectory(path)
	} else {
		err = rh.fileManager.CreateFile(path)
	}

	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileDelete - Dosya/Klasör sil
func (rh *RemoteHandler) HandleFileDelete(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	permanent := getBoolOrDefault(data, "permanent", false)

	err := rh.fileManager.Delete(path, permanent)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileRename - Yeniden adlandır
func (rh *RemoteHandler) HandleFileRename(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	newName := getStringOrDefault(data, "newName", "")

	err := rh.fileManager.Rename(path, newName)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileCopy - Kopyala
func (rh *RemoteHandler) HandleFileCopy(data map[string]interface{}) map[string]interface{} {
	src := getStringOrDefault(data, "src", "")
	dst := getStringOrDefault(data, "dst", "")

	err := rh.fileManager.Copy(src, dst)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileMove - Taşı
func (rh *RemoteHandler) HandleFileMove(data map[string]interface{}) map[string]interface{} {
	src := getStringOrDefault(data, "src", "")
	dst := getStringOrDefault(data, "dst", "")

	err := rh.fileManager.Move(src, dst)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileRead - Dosya oku
func (rh *RemoteHandler) HandleFileRead(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	maxSize := int64(getIntOrDefault(data, "maxSize", 1024*1024))

	content, err := rh.fileManager.ReadFile(path, maxSize)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"content":  content,
	}
}

// HandleFileWrite - Dosyaya yaz
func (rh *RemoteHandler) HandleFileWrite(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	content := getStringOrDefault(data, "content", "")
	append := getBoolOrDefault(data, "append", false)

	err := rh.fileManager.WriteFile(path, content, append)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileSearch - Dosya ara
func (rh *RemoteHandler) HandleFileSearch(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	pattern := getStringOrDefault(data, "pattern", "")
	maxResults := getIntOrDefault(data, "maxResults", 100)
	includeHidden := getBoolOrDefault(data, "includeHidden", false)

	results, err := rh.fileManager.Search(path, pattern, maxResults, includeHidden)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"results":  results,
	}
}

// HandleFileCompress - Sıkıştır
func (rh *RemoteHandler) HandleFileCompress(data map[string]interface{}) map[string]interface{} {
	pathsRaw, ok := data["paths"].([]interface{})
	if !ok {
		return map[string]interface{}{"basarili": false, "hata": "paths dizisi gerekli"}
	}

	paths := make([]string, len(pathsRaw))
	for i, p := range pathsRaw {
		paths[i] = p.(string)
	}

	outputPath := getStringOrDefault(data, "outputPath", "")

	err := rh.fileManager.Compress(paths, outputPath)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileExtract - Çıkart
func (rh *RemoteHandler) HandleFileExtract(data map[string]interface{}) map[string]interface{} {
	zipPath := getStringOrDefault(data, "zipPath", "")
	outputPath := getStringOrDefault(data, "outputPath", "")

	err := rh.fileManager.Extract(zipPath, outputPath)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleFileDownloadStart - Dosya indirme başlat
func (rh *RemoteHandler) HandleFileDownloadStart(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")

	transfer, err := rh.fileManager.StartDownload(path)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"transfer": transfer,
	}
}

// HandleFileDownloadChunk - İndirme chunk'ı al
func (rh *RemoteHandler) HandleFileDownloadChunk(data map[string]interface{}) map[string]interface{} {
	transferID := getStringOrDefault(data, "transferId", "")
	chunkIndex := getIntOrDefault(data, "chunkIndex", 0)

	chunk, err := rh.fileManager.GetDownloadChunk(transferID, chunkIndex)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"chunk":    chunk,
	}
}

// HandleFileUploadStart - Dosya yükleme başlat
func (rh *RemoteHandler) HandleFileUploadStart(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	fileName := getStringOrDefault(data, "fileName", "")
	fileSize := int64(getIntOrDefault(data, "fileSize", 0))

	transfer, err := rh.fileManager.StartUpload(path, fileName, fileSize)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"transfer": transfer,
	}
}

// HandleFileUploadChunk - Yükleme chunk'ı gönder
func (rh *RemoteHandler) HandleFileUploadChunk(data map[string]interface{}) map[string]interface{} {
	chunk := &filemanager.FileChunk{
		TransferID: getStringOrDefault(data, "transferId", ""),
		ChunkIndex: getIntOrDefault(data, "chunkIndex", 0),
		Data:       getStringOrDefault(data, "data", ""),
		Size:       getIntOrDefault(data, "size", 0),
		Hash:       getStringOrDefault(data, "hash", ""),
	}

	err := rh.fileManager.UploadChunk(chunk)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// ============== PROCESS MANAGER ==============

// HandleProcessList - Süreç listesi
func (rh *RemoteHandler) HandleProcessList(data map[string]interface{}) map[string]interface{} {
	sortBy := getStringOrDefault(data, "sortBy", "cpu")
	sortDesc := getBoolOrDefault(data, "sortDesc", true)
	filter := getStringOrDefault(data, "filter", "")

	processes, err := rh.processManager.GetAllProcesses(sortBy, sortDesc, filter)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili":  true,
		"processes": processes,
	}
}

// HandleProcessInfo - Tek süreç bilgisi
func (rh *RemoteHandler) HandleProcessInfo(data map[string]interface{}) map[string]interface{} {
	pid := int32(getIntOrDefault(data, "pid", 0))

	info, err := rh.processManager.GetProcess(pid)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"process":  info,
	}
}

// HandleProcessKill - Süreç sonlandır
func (rh *RemoteHandler) HandleProcessKill(data map[string]interface{}) map[string]interface{} {
	pid := int32(getIntOrDefault(data, "pid", 0))
	force := getBoolOrDefault(data, "force", false)

	err := rh.processManager.KillProcess(pid, force)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleProcessSuspend - Süreç duraklat
func (rh *RemoteHandler) HandleProcessSuspend(data map[string]interface{}) map[string]interface{} {
	pid := int32(getIntOrDefault(data, "pid", 0))

	err := rh.processManager.SuspendProcess(pid)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleProcessResume - Süreç devam ettir
func (rh *RemoteHandler) HandleProcessResume(data map[string]interface{}) map[string]interface{} {
	pid := int32(getIntOrDefault(data, "pid", 0))

	err := rh.processManager.ResumeProcess(pid)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandleProcessTree - Süreç ağacı
func (rh *RemoteHandler) HandleProcessTree() map[string]interface{} {
	tree, err := rh.processManager.GetProcessTree()
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"tree":     tree,
	}
}

// HandleProcessStats - Sistem süreç istatistikleri
func (rh *RemoteHandler) HandleProcessStats() map[string]interface{} {
	stats, err := rh.processManager.GetSystemProcessStats()
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"stats":    stats,
	}
}

// HandleProcessStart - Yeni süreç başlat
func (rh *RemoteHandler) HandleProcessStart(data map[string]interface{}) map[string]interface{} {
	path := getStringOrDefault(data, "path", "")
	cwd := getStringOrDefault(data, "cwd", "")

	var args []string
	if argsRaw, ok := data["args"].([]interface{}); ok {
		for _, a := range argsRaw {
			args = append(args, a.(string))
		}
	}

	var env map[string]string
	if envRaw, ok := data["env"].(map[string]interface{}); ok {
		env = make(map[string]string)
		for k, v := range envRaw {
			env[k] = v.(string)
		}
	}

	pid, err := rh.processManager.StartProcess(path, args, cwd, env)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"pid":      pid,
	}
}

// ============== PLUGIN MANAGER ==============

// HandlePluginList - Plugin listesi
func (rh *RemoteHandler) HandlePluginList() map[string]interface{} {
	plugins := rh.pluginManager.GetPlugins()
	return map[string]interface{}{
		"basarili": true,
		"plugins":  plugins,
	}
}

// HandlePluginLoad - Plugin yükle
func (rh *RemoteHandler) HandlePluginLoad(data map[string]interface{}) map[string]interface{} {
	pluginID := getStringOrDefault(data, "pluginId", "")

	err := rh.pluginManager.LoadPlugin(pluginID)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandlePluginUnload - Plugin kaldır
func (rh *RemoteHandler) HandlePluginUnload(data map[string]interface{}) map[string]interface{} {
	pluginID := getStringOrDefault(data, "pluginId", "")

	err := rh.pluginManager.UnloadPlugin(pluginID)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandlePluginStart - Plugin başlat
func (rh *RemoteHandler) HandlePluginStart(data map[string]interface{}) map[string]interface{} {
	pluginID := getStringOrDefault(data, "pluginId", "")

	err := rh.pluginManager.StartPlugin(pluginID)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandlePluginStop - Plugin durdur
func (rh *RemoteHandler) HandlePluginStop(data map[string]interface{}) map[string]interface{} {
	pluginID := getStringOrDefault(data, "pluginId", "")

	err := rh.pluginManager.StopPlugin(pluginID)
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{"basarili": true}
}

// HandlePluginStats - Plugin istatistikleri
func (rh *RemoteHandler) HandlePluginStats() map[string]interface{} {
	stats := rh.pluginManager.GetPluginStats()
	return map[string]interface{}{
		"basarili": true,
		"stats":    stats,
	}
}

// ============== UPDATER ==============

// HandleUpdateCheck - Güncelleme kontrolü
func (rh *RemoteHandler) HandleUpdateCheck() map[string]interface{} {
	update, err := rh.updater.CheckForUpdates()
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili":     true,
		"hasUpdate":    update != nil,
		"updateInfo":   update,
	}
}

// HandleUpdateInstall - Güncelleme kur
func (rh *RemoteHandler) HandleUpdateInstall() map[string]interface{} {
	update := rh.updater.GetLastUpdate()
	if update == nil {
		return map[string]interface{}{"basarili": false, "hata": "mevcut güncelleme yok"}
	}

	go rh.updater.DownloadAndInstall(update)

	return map[string]interface{}{
		"basarili": true,
		"mesaj":    "güncelleme başlatıldı",
	}
}

// HandleUpdateStatus - Güncelleme durumu
func (rh *RemoteHandler) HandleUpdateStatus() map[string]interface{} {
	status := rh.updater.GetUpdateStatus()
	return map[string]interface{}{
		"basarili": true,
		"status":   status,
	}
}

// HandleUpdateRollback - Geri al
func (rh *RemoteHandler) HandleUpdateRollback() map[string]interface{} {
	err := rh.updater.Rollback()
	if err != nil {
		return map[string]interface{}{"basarili": false, "hata": err.Error()}
	}

	return map[string]interface{}{
		"basarili": true,
		"mesaj":    "geri alma tamamlandı, yeniden başlatma gerekli",
	}
}

// ============== GENEL İŞLEVLER ==============

// ProcessEvent - Gelen eventi işle
func (rh *RemoteHandler) ProcessEvent(eventName string, data map[string]interface{}) map[string]interface{} {
	switch eventName {
	// Screen
	case "screen.capture":
		return rh.HandleScreenCapture(data)
	case "screen.stream.start":
		return rh.HandleScreenStreamStart(data)
	case "screen.stream.stop":
		return rh.HandleScreenStreamStop()
	case "screen.stream.config":
		return rh.HandleScreenStreamConfig(data)
	case "screen.displays":
		return rh.HandleGetDisplays()

	// WebRTC
	case "webrtc.start":
		return rh.HandleWebRTCStart(data)
	case "webrtc.answer":
		return rh.HandleWebRTCAnswer(data)
	case "webrtc.offer":
		return rh.HandleWebRTCOffer(data)
	case "webrtc.ice":
		return rh.HandleWebRTCICECandidate(data)
	case "webrtc.stop":
		return rh.HandleWebRTCStop()
	case "webrtc.stats":
		return rh.HandleWebRTCStats()

	// Input
	case "input.mouse.move":
		return rh.HandleMouseMove(data)
	case "input.mouse.click":
		return rh.HandleMouseClick(data)
	case "input.mouse.down":
		return rh.HandleMouseDown(data)
	case "input.mouse.up":
		return rh.HandleMouseUp(data)
	case "input.mouse.scroll":
		return rh.HandleMouseScroll(data)
	case "input.key.press":
		return rh.HandleKeyPress(data)
	case "input.key.down":
		return rh.HandleKeyDown(data)
	case "input.key.up":
		return rh.HandleKeyUp(data)
	case "input.type":
		return rh.HandleTypeText(data)
	case "input.combination":
		return rh.HandleKeyCombination(data)
	case "input.enable":
		return rh.HandleInputEnable()
	case "input.disable":
		return rh.HandleInputDisable()

	// File
	case "file.list":
		return rh.HandleFileList(data)
	case "file.drives":
		return rh.HandleFileGetDrives()
	case "file.info":
		return rh.HandleFileInfo(data)
	case "file.create":
		return rh.HandleFileCreate(data)
	case "file.delete":
		return rh.HandleFileDelete(data)
	case "file.rename":
		return rh.HandleFileRename(data)
	case "file.copy":
		return rh.HandleFileCopy(data)
	case "file.move":
		return rh.HandleFileMove(data)
	case "file.read":
		return rh.HandleFileRead(data)
	case "file.write":
		return rh.HandleFileWrite(data)
	case "file.search":
		return rh.HandleFileSearch(data)
	case "file.compress":
		return rh.HandleFileCompress(data)
	case "file.extract":
		return rh.HandleFileExtract(data)
	case "file.download.start":
		return rh.HandleFileDownloadStart(data)
	case "file.download.chunk":
		return rh.HandleFileDownloadChunk(data)
	case "file.upload.start":
		return rh.HandleFileUploadStart(data)
	case "file.upload.chunk":
		return rh.HandleFileUploadChunk(data)

	// Process
	case "process.list":
		return rh.HandleProcessList(data)
	case "process.info":
		return rh.HandleProcessInfo(data)
	case "process.kill":
		return rh.HandleProcessKill(data)
	case "process.suspend":
		return rh.HandleProcessSuspend(data)
	case "process.resume":
		return rh.HandleProcessResume(data)
	case "process.tree":
		return rh.HandleProcessTree()
	case "process.stats":
		return rh.HandleProcessStats()
	case "process.start":
		return rh.HandleProcessStart(data)

	// Plugin
	case "plugin.list":
		return rh.HandlePluginList()
	case "plugin.load":
		return rh.HandlePluginLoad(data)
	case "plugin.unload":
		return rh.HandlePluginUnload(data)
	case "plugin.start":
		return rh.HandlePluginStart(data)
	case "plugin.stop":
		return rh.HandlePluginStop(data)
	case "plugin.stats":
		return rh.HandlePluginStats()

	// Update
	case "update.check":
		return rh.HandleUpdateCheck()
	case "update.install":
		return rh.HandleUpdateInstall()
	case "update.status":
		return rh.HandleUpdateStatus()
	case "update.rollback":
		return rh.HandleUpdateRollback()

	default:
		return map[string]interface{}{
			"basarili": false,
			"hata":     "bilinmeyen event: " + eventName,
		}
	}
}

// ToJSON - Map'i JSON'a çevir
func ToJSON(data interface{}) string {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "{}"
	}
	return string(bytes)
}

// Helper fonksiyonları
func getStringOrDefault(m map[string]interface{}, key, defaultVal string) string {
	if v, ok := m[key].(string); ok {
		return v
	}
	return defaultVal
}

func getIntOrDefault(m map[string]interface{}, key string, defaultVal int) int {
	if v, ok := m[key].(float64); ok {
		return int(v)
	}
	if v, ok := m[key].(int); ok {
		return v
	}
	return defaultVal
}

func getFloatOrDefault(m map[string]interface{}, key string, defaultVal float64) float64 {
	if v, ok := m[key].(float64); ok {
		return v
	}
	return defaultVal
}

func getBoolOrDefault(m map[string]interface{}, key string, defaultVal bool) bool {
	if v, ok := m[key].(bool); ok {
		return v
	}
	return defaultVal
}