cmd

var (
	Conf       = "./server/conf/db.toml"
	OutObj     = "./domain/object"
	OutFunc    = "./adapter/repository"
	NewCRUDCmd = &cobra.Command{
		Use:   "new-crud",
		Short: "Create the model code for the CRUD.",
		Long:  `Create the model code for the CRUD, You can view subcommands and customize builds`,
		RunE: func(cmd *cobra.Command, args []string) (err error) {
			tl := crud.CrudTemplate()
			funTempl := crud.FunTemplate()
			s2 := crud.NewTable2Struct()
			dc := DBConf{}
			if err = configure(&dc, Conf); err != nil {
				return
			}
			list, err := s2.Dsn(dc.Addr).Run()
			if err != nil {
				return err
			}
			generateBuffer := new(bytes.Buffer)
			tmpl, err := template.New("").Parse(crud.FunTemplatePackage())
			if err != nil {
				return err
			}

			sysPath, err := os.Getwd()
			if err != nil {
				return err
			}
			pkg, err := build.ImportDir(sysPath+"/domain/object", build.IgnoreVendor)
			if err != nil {
				return err
			}
			pdata := map[string]interface{}{
				"PackagePath": pkg.ImportPath,
			}
			if err = tmpl.Execute(generateBuffer, pdata); err != nil {
				return err
			}

			for index := 0; index < len(list); index++ {
				pdata := map[string]interface{}{
					"Name":         list[index].Name,
					"Content":      list[index].Content,
					"Time":         false,
					"Fields":       list[index].Fields,
					"NumberFields": list[index].NumberFields,
					"Import":       "",
				}
				if strings.Contains(list[index].Content, "time.Time") {
					pdata["Import"] = "import (" + "\n" + `"time"`
				}
				if len(list[index].NumberFields) > 0 {
					pdata["Import"] = pdata["Import"].(string) + "\n" + `"github.com/jinzhu/gorm"`
				}

				if pdata["Import"].(string) != "" {
					pdata["Import"] = pdata["Import"].(string) + "\n)"
				}

				var pf *os.File
				pf, err = os.Create(OutObj + "/" + list[index].TableRealName + ".go")
				if err != nil {
					return err
				}
				tmpl, err := template.New("").Parse(tl)
				if err != nil {
					return err
				}
				if err = tmpl.Execute(pf, pdata); err != nil {
					return err
				}

				tmpl, err = template.New("").Parse(funTempl)
				if err != nil {
					return err
				}
				if err = tmpl.Execute(generateBuffer, pdata); err != nil {
					return err
				}
			}
			ioutil.WriteFile(OutFunc+"/"+"generate.go", generateBuffer.Bytes(), 0755)
			exec.Command("gofmt", "-w", OutObj).Output()
			exec.Command("gofmt", "-w", OutFunc).Output()

			return nil
		}}
)

var (
	NewProjectCmd = &cobra.Command{
		Use:   "new-project [project_name]",
		Short: "New a microservice project based on freedom",
		Long:  `New project from freedom project template. `,
		RunE: func(cmd *cobra.Command, args []string) (err error) {
			if len(args) < 1 || args[0] == "" {
				return errors.New("[project_name] empty")
			}
			sysPath, err := filepath.Abs(args[0])
			if err != nil {
				return
			}

			projectPath := strings.Replace(sysPath, build.Default.GOPATH+"/src/", "", 1)
			projectName := args[0]
			pdata := map[string]interface{}{
				"PackagePath": projectPath,
				"PackageName": projectName,
				"VersionNum":  versionNum,
			}
			if !strings.Contains(sysPath, build.Default.GOPATH) {
				pdata["PackagePath"] = projectName
			}

			mkdirAll(sysPath)
			m := project.FileContent()
			for filepath, content := range m {
				var pf *os.File
				pf, err = os.Create(sysPath + filepath)
				if err != nil {
					return err
				}
				tmpl, err := template.New(projectName).Parse(content)
				if err = tmpl.Execute(pf, pdata); err != nil {
					return err
				}
			}
			exec.Command("gofmt", "-w", sysPath).Output()
			return nil
		},
	}
)

var (
	VersionCmd = &cobra.Command{
		Use:   "version",
		Short: "Output current version number",
		Long:  `Output current version number`,
		RunE: func(cmd *cobra.Command, args []string) (err error) {
			fmt.Println("freedom " + versionNum)
			return
		},
	}
)