main

func (*GenerateCmd) Run() error
{
	config := &PallasConfig{
		Dest:    c.Dest,
		Title:   c.Title,
		Readme:  c.Readme,
		Project: c.ProjectFlag,
	}

	if c.ProjectArg != "" {
		config.Project = c.ProjectArg
	}

	projectPath := config.Project
	if projectPath == "" {
		projectPath = "."
	}
	projectPath, _ = filepath.Abs(projectPath)

	outputDir := config.Dest
	if outputDir == "." || outputDir == "" || outputDir == "/" {
		outputDir = "./dist"
	}
	outputDir, _ = filepath.Abs(outputDir)

	if strings.HasPrefix(projectPath, outputDir) && projectPath == outputDir {
		return fmt.Errorf("output directory cannot be the same as project directory")
	}

	fmt.Println("Generating documentation for:", projectPath)
	fmt.Println("Output directory:", outputDir)

	if err := os.RemoveAll(outputDir); err != nil {
		return fmt.Errorf("error cleaning output directory: %v", err)
	}
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		return fmt.Errorf("error creating output directory: %v", err)
	}

	pkgDirs, err := parser.GetPackages(projectPath)
	if err != nil {
		return fmt.Errorf("error finding packages: %v", err)
	}

	var entities []parser.EntityInfo
	var imports []parser.ImportInfo
	seenPackages := make(map[string]bool)

	for _, pkgDir := range pkgDirs {
		rel, _ := filepath.Rel(projectPath, pkgDir)
		ents, imps, err := parser.ParseEntitiesInPackage(projectPath, pkgDir, rel)
		if err != nil {
			fmt.Printf("Warning: failed to parse package %s: %v\n", rel, err)
			continue
		}

		if len(ents) > 0 {
			for i := range ents {
				if relFile, err := filepath.Rel(projectPath, ents[i].File); err == nil {
					ents[i].File = relFile
				}
			}
		}

		entities = append(entities, ents...)
		imports = append(imports, imps...)
	}

	var packageLinks []generator.PackageLink
	for _, e := range entities {
		pkg := e.Package
		if pkg == "" {
			pkg = "main"
		}
		if !seenPackages[pkg] {
			seenPackages[pkg] = true
			packageLinks = append(packageLinks, generator.PackageLink{
				Name: pkg,
				Link: "pkg_" + sanitizePackageName(pkg) + ".html",
			})
		}
	}

	fmt.Printf("Found %d entities and %d imports\n", len(entities), len(imports))

	readmePath := filepath.Join(projectPath, config.Readme)
	readmeContent := ""
	readmeRaw := ""

	// Attempt to locate and read the README file
	if _, err := os.Stat(readmePath); err == nil {
		content, _ := os.ReadFile(readmePath)
		readmeRaw = string(content)
		readmeContent = markdownToHTML(readmeRaw)
	} else {
		readmePath = filepath.Join(projectPath, strings.ToLower(config.Readme))
		if _, err := os.Stat(readmePath); err == nil {
			content, _ := os.ReadFile(readmePath)
			readmeRaw = string(content)
			readmeContent = markdownToHTML(readmeRaw)
		}
	}

	toc := extractTOC(readmeRaw)

	// Auto-detect project title from directory name if default is used
	if config.Title == "Pallas" {
		base := filepath.Base(projectPath)
		if base != "." && base != "/" {
			if len(base) > 0 {
				clean := strings.ReplaceAll(base, "-", " ")
				clean = strings.ReplaceAll(clean, "_", " ")
				clean = strings.ReplaceAll(clean, ".", " ")
				config.Title = strings.Title(clean)
			} else {
				config.Title = base
			}
		}
	}

	initials := getInitials(config.Title)
	modulePath := getModulePath(projectPath)

	// Process docs/ directory with hierarchical structure
	var docPages []generator.DocPage
	docSectionsMap := make(map[string]*generator.DocSection)
	var docSections []generator.DocSection

	docsDir := filepath.Join(projectPath, "docs")
	if info, err := os.Stat(docsDir); err == nil && info.IsDir() {
		filepath.WalkDir(docsDir, func(path string, d os.DirEntry, err error) error {
			if err != nil {
				return nil
			}
			if d.IsDir() || !strings.HasSuffix(d.Name(), ".md") {
				return nil
			}

			content, _ := os.ReadFile(path)
			htmlContent := markdownToHTML(string(content))

			relPath, _ := filepath.Rel(docsDir, path)
			dir := filepath.Dir(relPath)
			baseName := strings.TrimSuffix(filepath.Base(relPath), ".md")

			// Flatten filename for output
			flatName := strings.ReplaceAll(strings.TrimSuffix(relPath, ".md"), string(filepath.Separator), "_")

			// Clean title from filename
			cleanTitle := strings.Title(strings.ReplaceAll(strings.ReplaceAll(baseName, "-", " "), "_", " "))

			page := generator.DocPage{
				Title:    cleanTitle,
				Filename: "doc_" + flatName + ".html",
				Content:  template.HTML(htmlContent),
				ID:       flatName,
			}

			if dir == "." {
				// Root level doc
				page.Section = ""
				docPages = append(docPages, page)
			} else {
				// Nested doc - belongs to a section
				sectionName := strings.Title(strings.ReplaceAll(strings.ReplaceAll(dir, "-", " "), "_", " "))
				page.Section = sectionName

				if docSectionsMap[sectionName] == nil {
					docSectionsMap[sectionName] = &generator.DocSection{
						Name:  sectionName,
						Pages: []generator.DocPage{},
					}
				}

				// Check if this is an index.md
				if baseName == "index" {
					docSectionsMap[sectionName].HasIndex = true
					page.Title = sectionName
				}

				docSectionsMap[sectionName].Pages = append(docSectionsMap[sectionName].Pages, page)
			}

			return nil
		})
	}

	// Convert map to slice
	for _, section := range docSectionsMap {
		docSections = append(docSections, *section)
	}

	// Combine all pages for search and generation
	var allDocPages []generator.DocPage
	allDocPages = append(allDocPages, docPages...)
	for _, section := range docSections {
		allDocPages = append(allDocPages, section.Pages...)
	}

	if err := generator.GenerateHTML(config.Title, config.Dest, entities, imports, readmeContent, initials, modulePath, allDocPages, docSections); err != nil {
		return fmt.Errorf("error generating HTML: %v", err)
	}

	if err := generator.GenerateIndex(config.Title, outputDir, entities, readmeContent, initials, toc, packageLinks, docPages, docSections); err != nil {
		return fmt.Errorf("error generating index: %v", err)
	}

	fmt.Println("Documentation generated successfully!")
	return nil
}