package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"kode-starter/config"
	"kode-starter/lists"
	"kode-starter/structures"
	"kode-starter/utils"
	"log"
	"net/http"
	"os"
	"os/exec"
	"strings"

	"github.com/joho/godotenv"
	"github.com/spf13/cobra"
)

func createReadme(projectName, description, author, url string) bool {
	file, err := os.Open("../readme.template")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	template := ""
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		line = strings.Replace(line, "<project_name>", projectName, -1)
		line = strings.Replace(line, "<description>", description, -1)
		line = strings.Replace(line, "<author>", author, -1)
		line = strings.Replace(line, "<gitea_project_url>", url, -1)
		template += line + "\n"
	}

	readmeFile, err := os.Create("README.md")
	if err != nil {
		log.Fatal(err)
	}
	defer readmeFile.Close()

	_, err = readmeFile.WriteString(template)
	if err != nil {
		log.Fatal(err)
	}
	return true
}

var rootCmd = &cobra.Command{
	Use:   "prj-creator.exe",
	Short: "Simple cli app create startup project",
	Long:  `A simple CLI app to work with Github, Gitea`,
	Run: func(cmd *cobra.Command, args []string) {

		config.SetInformations(cmd, args, token)
		mainProgram(cmd, args)
	},
}

var createCmd = &cobra.Command{
	Use:   "create",
	Short: "Create Github project",
	Long:  `A simple CLI app to create a startup project on Github`,
	Run: func(cmd *cobra.Command, args []string) {
		config.SetInformations(cmd, args, token)
		createProject()
	},
}

var token, org, name, private, description string
var verbose, createFlag bool

func init() {

	rootCmd.Flags().BoolP("help", "h", false, "Show help for create command")

	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "mode verbose")
	rootCmd.PersistentFlags().BoolVarP(&createFlag, "json", "j", false, "Print output as json format")

	lists.ListCmd.Flags().StringVarP(&token, "token", "t", "", "Github token")
	lists.ListCmd.Flags().StringVarP(&org, "org", "o", "", "Github organization")

	createCmd.Flags().StringVarP(&token, "token", "t", "", "Github token")
	createCmd.Flags().StringVarP(&org, "org", "o", "", "Github organization")
	createCmd.Flags().StringVarP(&name, "name", "n", "", "Project name")
	createCmd.Flags().StringVarP(&description, "desc", "d", "", "Description")
	createCmd.Flags().StringVarP(&private, "private", "p", "", "true/false")

	rootCmd.AddCommand(lists.ListCmd)
	rootCmd.AddCommand(createCmd)

}

func mainProgram(cmd *cobra.Command, args []string) {

	// Check if the help flag is set
	if cmd.Flags().Changed("help") || cmd.Flags().Changed("h") {
		printHelpFormated(cmd)
		return
	} else {
		// If no flag is set, show help
		printHelpFormated(cmd)
		return
	}

}

func createProject() {

	godotenv.Load()

	fmt.Printf("Token: %s\n", config.GetToken())

	// Construct POST data
	data := structures.Project{
		Name:        name,
		Description: description,
		Private:     private == "true",
	}

	// Make API request to create Github project
	jsonData, _ := json.Marshal(data)
	req, err := http.NewRequest("POST",
		fmt.Sprintf("%s/%s/repos", config.GetUrlApiOrgs(), org),
		bytes.NewBuffer(jsonData))
	req.Header.Set("Authorization", "token "+config.GetToken())
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		log.Fatalln(err)
	}

	var dataReceived structures.GitOrgsRepoResponse
	err = json.NewDecoder(res.Body).Decode(&dataReceived)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("==> Created project '%s' URL: '%s'\n", name, dataReceived.CloneURL)

	defer res.Body.Close()

	// Create directory of the project
	fmt.Println("==> Creating directory...")
	utils.CreateDir(name)
	fmt.Println("==> Created directory")

	// Change to project directory
	err = os.Chdir(name)
	if err != nil {
		log.Fatal(err)
	}

	isCreated := createReadme(name, description, "BC", "")
	if isCreated {
		fmt.Println("==> Created README.md")
	}

	// Git commands
	gitCmd := exec.Command("git", "init")
	err = gitCmd.Run()
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Printf("==> Initialized empty Git repository in %s\n", name)
	}

	gitCmd = exec.Command("git", "checkout", "-b", "main")
	err = gitCmd.Run()
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("==> Switched to a new branch 'main'")
	}

	gitCmd = exec.Command("git", "add", "-A")
	err = gitCmd.Run()
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("==> Switched to a new branch 'main'")
	}

	gitCmd = exec.Command("git", "commit", "-m", "first commit from project creator !")
	err = gitCmd.Run()
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("==> first commit from project creator !")
	}

	// Get project info from API response
	var project structures.Project
	json.NewDecoder(res.Body).Decode(&project)
	fmt.Println(project)

}

func printHelpFormated(cmd *cobra.Command) {

	var line string = "---   ---   ---   ---   ---   ---   ---   ---   ---   ---   ---   ---   ---"
	fmt.Println("")
	cmd.Help()
	fmt.Println("")
	fmt.Println(line)
	fmt.Println("|  Version: " + config.GetVersion().String() + "  ||  Author: " + config.GetAuthor() + "  ||  Build date: " + config.GetBuildDate() + "  |")
	fmt.Println(line)
	fmt.Println("")
}

func main() {

	fmt.Println("==> Project Creator CLI")
	versionString := config.GetVersion()
	fmt.Println(versionString)

	rootCmd.Execute()

}