changeset

var AddChangeset = func(bump string, summary string, apply bool) {
	if !utilsIsValidPlasmoid() {
		fmt.Println(color.RedString("Current directory is not a valid plasmoid"))
		return
	}
	version, verr := utilsGetDataFromMetadata("Version")
	id, ierr := utilsGetDataFromMetadata("Id")
	if verr != nil || ierr != nil {
		fmt.Println(color.RedString("Invalid metadata: %v", fmt.Sprintf("%v or %v", ierr, verr)))
		return
	}
	var next string

	if bump == "" || !validBumps[bump] {
		bumpLabels := make(map[string]string)
		for _, bumpType := range []string{"patch", "minor", "major"} {
			if nextVer, err := GetNextVersion(version.(string), bumpType); err == nil {
				bumpLabels[bumpType] = fmt.Sprintf("%s (%s)", bumpType, nextVer)
			} else {
				fmt.Println(color.RedString("Failed to compute next version for %s: %v", bumpType, err))
				return
			}
		}

		options := []string{bumpLabels["patch"], bumpLabels["minor"], bumpLabels["major"]}

		var selected string
		err := surveyAskOne(&survey.Select{
			Message: "Select version bump:",
			Options: options,
			Default: bumpLabels["patch"],
		}, &selected, survey.WithValidator(survey.Required))

		if err != nil {
			fmt.Println(color.RedString("Failed to prompt for version bump: %v", err))
			return
		}

		parts := strings.SplitN(selected, " ", 2)
		bump = parts[0]
	}

	if next == "" {
		var err error
		next, err = GetNextVersion(version.(string), bump)
		if err != nil {
			fmt.Println(color.RedString("Failed to compute next version for %s: %v", bump, err))
			return
		}
	}

	if summary == "" {
		var err error
		summary, err = OpenEditor()
		if err != nil || strings.TrimSpace(summary) == "" {

			prompt := &survey.Input{
				Message: "Enter changelog summary:",
			}
			err = surveyAskOne(prompt, &summary, survey.WithValidator(survey.Required))

			if err != nil {
				fmt.Println(color.RedString("Failed to prompt for changelog summary: %v", err))
				return
			}
		}
	}

	if err := osMkdirAll(ChangesFolder, 0755); err != nil {
		fmt.Println(color.RedString("Failed to create changes directory: %v", err))
		return
	}

	now := time.Now()
	timestamp := now.Format("2006-01-02-15-04")
	dateOnly := now.Format("2006-01-02")
	filename := filepath.Join(ChangesFolder, fmt.Sprintf("%s-%s.mdx", timestamp, bump))

	content := fmt.Sprintf(`---
id: %s
bump: %s
next: %s
date: %s
---		

%s
`, id, bump, next, dateOnly, summary)

	if err := osWriteFile(filename, []byte(content), 0644); err != nil {
		fmt.Println(color.RedString("Failed to write changeset: %v", err))
		return
	}

	if apply {
		ApplyChanges()
	}
}

var ApplyChanges = func() {
	changesetFiles := []string{}
	err := filepathWalk(".changes", func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			return nil
		}
		if filepath.Ext(path) == ".mdx" {
			changesetFiles = append(changesetFiles, path)
		}
		return nil
	})
	if err != nil {
		fmt.Println(color.RedString("Failed to walk changes directory: %v", err))
		return
	}

	if len(changesetFiles) == 0 {
		fmt.Println(color.YellowString("No changeset files found."))
		fmt.Println(color.CyanString("run `prasmoid changeset add` to create a changeset."))
		return
	}

	for _, file := range changesetFiles {
		data, err := osReadFile(file)
		if err != nil {
			fmt.Println(color.RedString("Failed to read changeset file %s: %v", file, err))
			continue
		}

		meta, body, err := matterParse(data)
		if err != nil {
			fmt.Println(color.RedString("Failed to parse %s: %v", file, err))
			continue
		}

		if err := utilsUpdateMetadata("Version", meta.Next); err != nil {
			fmt.Println(color.RedString("Metadata update failed in %s: %v", file, err))
			continue
		}

		if err := UpdateChangelog(meta.Next, meta.Date, body); err != nil {
			fmt.Println(color.RedString("Changelog update failed in %s: %v", file, err))
			continue
		}

		if err := osRemove(file); err != nil {
			fmt.Println(color.RedString("Failed to remove changeset file %s: %v", file, err))
			continue
		}
	}

	fmt.Println(color.GreenString("All changesets applied successfully!"))
}

var ChangesFolder string = ".changes"

var GetNextVersion = func(version string, bump string) (string, error) {
	versionParts := strings.Split(version, ".")
	if len(versionParts) != 3 {
		return "", fmt.Errorf("invalid version format: %s, expected format: major.minor.patch", version)
	}

	major, err1 := strconv.Atoi(versionParts[0])
	minor, err2 := strconv.Atoi(versionParts[1])
	patch, err3 := strconv.Atoi(versionParts[2])
	if err1 != nil || err2 != nil || err3 != nil {
		return "", fmt.Errorf("version parts must be integers: %v %v %v", err1, err2, err3)
	}

	switch bump {
	case "patch":
		patch++
	case "minor":
		minor++
		patch = 0
	case "major":
		major++
		minor = 0
		patch = 0
	default:
		return "", fmt.Errorf("invalid bump type: %s, must be 'major', 'minor' or 'patch'", bump)
	}

	return fmt.Sprintf("%d.%d.%d", major, minor, patch), nil
}

var OpenEditor = func() (string, error) {
	editor := osGetenv("EDITOR")
	if editor == "" {
		editor = "nano"
	}

	tmpFile, err := osCreateTemp("", "changeset-*.mdx")
	if err != nil {
		return "", err
	}
	defer func() {
		if err := osRemove(tmpFile.Name()); err != nil {
			log.Printf("Error removing temporary file: %v", err)
		}
	}()

	if _, err := tmpFile.WriteString(`# Write your changelog entry below.
# Lines starting with # will be ignored.
# Example: Added system tray widget for memory usage.
`); err != nil {
		return "", err
	}
	if err := tmpFile.Close(); err != nil {
		return "", err
	}

	cmd := execCommand(editor, tmpFile.Name())
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if err := cmd.Run(); err != nil {
		return "", err
	}

	data, err := osReadFile(tmpFile.Name())
	if err != nil {
		return "", err
	}

	lines := strings.Split(string(data), "\n")
	var cleaned []string
	for _, line := range lines {
		if !strings.HasPrefix(line, "#") && strings.TrimSpace(line) != "" {
			cleaned = append(cleaned, line)
		}
	}

	return strings.Join(cleaned, "\n"), nil
}

var UpdateChangelog = func(version, date, body string) error {
	const changelogPath = "CHANGELOG.md"

	newEntry := fmt.Sprintf("## [v%s] - %s\n\n%s\n\n", version, date, strings.TrimSpace(body))

	if _, err := osStat(changelogPath); os.IsNotExist(err) {
		initial := "# CHANGELOG\n\n" + newEntry
		return osWriteFile(changelogPath, []byte(initial), 0644)
	}

	data, err := osReadFile(changelogPath)
	if err != nil {
		return fmt.Errorf("failed to read changelog: %w", err)
	}

	content := string(data)

	parts := strings.SplitN(content, "\n", 2)
	header := parts[0]
	rest := ""
	if len(parts) > 1 {
		rest = parts[1]
	}

	updated := header + "\n\n" + newEntry + strings.TrimPrefix(rest, "\n")

	if err := osWriteFile(changelogPath, []byte(updated), 0644); err != nil {
		return fmt.Errorf("failed to write changelog: %w", err)
	}

	return nil
}