var rootCommand = &cobra.Command{
    Use:   "nk",
    Short: "nk: 一個神奇的文檔生成工具",
    Long:  "nk是一個強大的文檔生成工具，旨在提供快速而高效的文檔生成體驗。",
}

var generateCommand = &cobra.Command{
    Use:     "generate",
    Aliases: []string{"g"},
    Short:   "generate: 啟動文檔生成",
    Long:    "generate命令用于啟動文檔生成。",
}

var docCommand = &cobra.Command{
    Use:   "doc",
    Short: "generate doc project: 生成文檔項目",
    Long:  "doc命令用于生成文檔項目。",
    Run:   runDocCommand,
}

func initDocCommand() {
    wd, err := os.Getwd()
    if err != nil {
        return
    }

    // 聲明命令參數(shù)
    docCommand.Flags().String("components-dir", path.Join(wd, "projects", "components"), "指定組件目錄的絕對路徑")
    docCommand.Flags().String("doc-dir", path.Join(wd, "projects", "design-doc"), "指定設計文檔目錄的絕對路徑")
    docCommand.Flags().String("docs-dir", path.Join(wd, "docs"), "指定文檔目錄的絕對路徑")
    docCommand.Flags().Bool("watch", true, "監(jiān)聽文件變化")
}

func init() {
    initDocCommand()
    generateCommand.AddCommand(docCommand)
    generateCommand.AddCommand(serviceCommand)
    generateCommand.AddCommand(staticIconsCommand)
    rootCommand.AddCommand(generateCommand)
}

nx g doc --components-dir xxxx

type Task struct {
    Name         string          // 任務名稱
    Work         func() error   // 任務執(zhí)行的函數(shù)
    Dependencies []*Task        // 依賴的任務
    mu           sync.Mutex     // 互斥鎖，用于同步
    cond         *sync.Cond     // 條件變量，用于等待任務完成
    done         bool           // 任務完成標志
    StartTime    time.Time      // 任務開始時間
    EndTime      time.Time      // 任務結束時間
    noOutputLog  bool           // 是否輸出日志
}

// printExecutionTime 輸出任務執(zhí)行時間
func printExecutionTime(task *Task) {
    executionTime := task.EndTime.Sub(task.StartTime).Milliseconds()
    color.Green.Println(fmt.Sprintf("[%s] 任務完成 執(zhí)行時間：%d 毫秒", task.Name, executionTime))
}

// NewTask 創(chuàng)建一個新任務
func NewTask(name string, work func() error) *Task {
    task := &Task{
        Name: name,
        Work: work,
        done: false,
    }
    task.cond = sync.NewCond(&task.mu)
    return task
}

// SetDependency 設置任務的依賴關系
func (t *Task) SetDependency(dependencies ...*Task) {
    t.Dependencies = append(t.Dependencies, dependencies...)
}

// WaitForDependencies 等待任務的依賴任務完成
func (t *Task) WaitForDependencies() {
    for _, dep := range t.Dependencies {
        dep.WaitForCompletion()
    }
}

// Run 運行任務
func (t *Task) Run() error {
    t.WaitForDependencies()

    t.mu.Lock()
    defer t.mu.Unlock()

    t.StartTime = time.Now()
    if !t.noOutputLog {
        color.Green.Println(fmt.Sprintf("[%s] 任務開始", t.Name))
    }
    err := t.Work()
    if err != nil {
        return err
    }
    t.EndTime = time.Now()

    t.done = true
    if !t.noOutputLog {
        printExecutionTime(t)
    }
    t.cond.Broadcast()

    return nil
}

// WaitForCompletion 等待任務完成
func (t *Task) WaitForCompletion() {
    t.mu.Lock()
    defer t.mu.Unlock()

    for !t.done {
        t.cond.Wait()
    }
}

// SerialTask 串行執(zhí)行任務
func SerialTask(tasks []*Task) {
    for _, task := range tasks {
        task.Run()
    }
}

// ParallelTask 并行執(zhí)行任務
func ParallelTask(tasks []*Task) {
    var wg sync.WaitGroup

    for _, task := range tasks {
        wg.Add(1)
        go func(t *Task) {
            defer wg.Done()
            t.Run()
        }(task)
    }

    wg.Wait()
}

var clearCacheTask = flows.NewTask("清除項目緩存", func() error {
    return nil
})
var copyProjectTask = flows.NewTask("復制項目模板", func() error {
    return nil
})
// 設置依賴 copyProjectTask 依賴 clearCacheTask任務
copyProjectTask.SetDependency(clearCacheTask)
var collectTemplateMetaTask = flows.NewTask("收集模板信息", func() error {
    return nil
})
flows.ParallelTask([]*flows.Task{
    clearCacheTask,
    copyProjectTask,
    collectTemplateMetaTask,
})

func convertToHTML(markdownContent string) string {
    var htmlOutput bytes.Buffer

    md := goldmark.New(
        goldmark.WithExtensions(extension.GFM),  // 支持GitHub風格的Markdown
        // 如果需要語法高亮，可以啟用以下代碼（需要配置chroma等選項）
        //goldmark.WithExtensions(
        //    highlighting.NewHighlighting(
        //        highlighting.WithStyle("github"),
        //        highlighting.WithFormatOptions(
        //            chromahtml.WithClasses(true),
        //        ),
        //    ),
        //),
        goldmark.WithRenderer(HtmlRenderer()),  // 使用自定義的HTML渲染器
        goldmark.WithRendererOptions(html.WithUnsafe()),  // 允許HTML渲染器輸出不安全的HTML
    )

    if err := md.Convert([]byte(markdownContent), &htmlOutput); err != nil {
        panic(err)
    }

    return htmlOutput.String()
}

// CustomHTMLRenderer 自定義渲染器
type CustomHTMLRenderer struct {
 html.Renderer
}

func HtmlRenderer() renderer.Renderer {
 return renderer.NewRenderer(renderer.WithNodeRenderers(util.Prioritized(NewRenderer(), 1000)))
}

func NewRenderer(opts ...html.Option) renderer.NodeRenderer {
 r := &CustomHTMLRenderer{
  Renderer: html.Renderer{
   Config: html.NewConfig(),
  },
 }

 for _, opt := range opts {
  opt.SetHTMLOption(&r.Config)
 }

 return r
}

// renderHeading 自定義標簽渲染
func (r *CustomHTMLRenderer) renderHeading(
 w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
 n := node.(*ast.Heading)
 if entering {
  lines := n.BaseBlock.Lines()
  if lines.Len() > 0 {
   at := n.BaseBlock.Lines().At(0)
   buf := at.Value(source)
   // 附加id
   n.SetAttribute([]byte("id"), buf)
  }

  _, _ = w.WriteString("<h")
  _ = w.WriteByte("0123456"[n.Level])
  if n.Attributes() != nil {
   html.RenderAttributes(w, node, html.HeadingAttributeFilter)
  }
  _ = w.WriteByte('>')
 } else {
  _, _ = w.WriteString("</h")
  _ = w.WriteByte("0123456"[n.Level])
  _, _ = w.WriteString(">\n")
 }
 return ast.WalkContinue, nil
}

func (r *CustomHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
 r.Renderer.RegisterFuncs(reg)
 // 注冊 覆蓋內置的標題渲染邏輯
 reg.Register(ast.KindHeading, r.renderHeading)
}

func ParseMarkdown(filePath string) (*Document, error) {
    // 讀取Markdown文件內容
    mdContent, err := ioutil.ReadFile(filePath)
    if err != nil {
        return nil, err
    }

    // 使用正則表達式提取YAML元數(shù)據(jù)部分
    re := regexp.MustCompile(`---\r*\n([\s\S]*?)\r*\n---`)
    match := re.FindStringSubmatch(string(mdContent))
    if len(match) < 2 {
        return nil, fmt.Errorf("YAML section not found")
    }

    // 獲取YAML元數(shù)據(jù)內容
    yamlContent := match[1]
    // 獲取除去YAML元數(shù)據(jù)的Markdown內容
    markdownContent := string(mdContent)[len(yamlContent)+8:]

    // 解析YAML元數(shù)據(jù)
    var metadata Metadata
    if err := yaml.Unmarshal([]byte(yamlContent), &metadata); err != nil {
        return nil, fmt.Errorf("error parsing YAML: %w", err)
    }

    // 獲取文件名（包括擴展名）
    fileNameWithExtension := filepath.Base(filePath)
    // 去除擴展名，獲得文件名
    fileName := strings.TrimSuffix(fileNameWithExtension, filepath.Ext(fileNameWithExtension))

    // 創(chuàng)建文檔對象，包括元數(shù)據(jù)和多語言HTML內容
    document := Document{
        Metadata: metadata,
        ZhCN:     convertToHTML(getSectionContent(markdownContent, "zh-CN")),
        EnUS:     convertToHTML(getSectionContent(markdownContent, "en-US")),
        FileKey:  fileName,
    }

    return &document, nil
}

func wrapperAnchor(content string, anchor string) string {
 return fmt.Sprintf(
  "<div class="doc-content">\n\t\t%s\n</div><nx-anchor container="#component-demo">%s</nx-anchor>", content, anchor)
}
// ...
templateString += wrapperAnchor(angularNonBindAble(templateContent), strings.Join(anchorLink, "\n"))

// registrationTask 注冊相關子任務&處理任務之間的依賴關系
func (receiver *CompileDocTask) registrationTask() {
    // 創(chuàng)建清除 design-doc 任務
    receiver.ClearDesignDocTask = flows.NewTask("清除 design-doc", receiver.clearTaskHandler)
    
    // 創(chuàng)建復制 design-doc 任務
    receiver.CopyDesignDocTask = flows.NewTask("復制 design-doc", receiver.copyDocProjectTaskHandler)
    
    // 設置復制任務依賴于清除任務
    receiver.CopyDesignDocTask.SetDependency(receiver.ClearDesignDocTask)
    
    // 創(chuàng)建收集全局文檔信息任務
    receiver.CollectGlobalDocsTask = flows.NewTask("收集全局文檔信息", receiver.collectGlobalDocsTaskHandler)
    
    // 創(chuàng)建收集組件文檔信息任務
    receiver.CollectComponentDocsTask = flows.NewTask("收集組件文檔信息", receiver.collectComponentDocsTaskHandler)
    
    // 創(chuàng)建生成全局文檔任務
    receiver.GenerateGlobalDocsTask = flows.NewTask("生成全局文檔", receiver.generateGlobalDocsTaskHandler)
    
    // 設置生成全局文檔任務依賴于復制和收集任務
    receiver.GenerateGlobalDocsTask.SetDependency(
        receiver.CopyDesignDocTask,
        receiver.CollectGlobalDocsTask,
    )
    
    // 創(chuàng)建生成demo文檔任務
    receiver.GenerateDemoDocsTask = flows.NewTask("生成demo文檔", receiver.generateDemoDocsTaskHandler)
    
    // 設置生成demo文檔任務依賴于收集組件文檔信息任務
    receiver.GenerateDemoDocsTask.SetDependency(receiver.CollectComponentDocsTask)
}

// CompileTask 編譯文檔 處理元數(shù)據(jù)收集，md文檔解析等
func (receiver *CompileDocTask) CompileTask() {
    // 并行執(zhí)行清除、復制、收集任務
    flows.ParallelTask([]*flows.Task{
        receiver.ClearDesignDocTask,
        receiver.CopyDesignDocTask,
        receiver.CollectComponentDocsTask,
        receiver.CollectGlobalDocsTask,
    })
}

// GenerateTask 將收集的信息整合到一起生成完整的組件庫文檔
func (receiver *CompileDocTask) GenerateTask() {
    // 并行執(zhí)行生成全局文檔和生成demo文檔任務
    flows.ParallelTask([]*flows.Task{
        receiver.GenerateGlobalDocsTask,
        receiver.GenerateDemoDocsTask,
    })
}

func runDocCommand(cmd *cobra.Command, _ []string) {
    componentsDir, _ := cmd.Flags().GetString("components-dir")
    docDir, _ := cmd.Flags().GetString("doc-dir")
    docsDir, _ := cmd.Flags().GetString("docs-dir")
    watch, _ := cmd.Flags().GetBool("watch")
    sourceDir := path.Join("design-doc") // 源目錄
    
    // 創(chuàng)建文檔生成任務
    compileDocTask := NewCompileDocTask(componentsDir, docDir, docsDir, sourceDir)
    
    // 執(zhí)行編譯任務
    compileDocTask.CompileTask()
    
    // 執(zhí)行生成任務
    compileDocTask.GenerateTask()
    
    if watch {
        // 監(jiān)聽單個文件的變化 實現(xiàn)局部更新
        watchDoc(cmd, compileDocTask)
    }
}