cmd

var (
	RootCmd = &cobra.Command{
		Use:   "gosaic",
		Short: "Create image mosaics",
		Long:  "Create image mosaics",
	}
	Env environment.Environment
)

var CompareCmd = &cobra.Command{
	Use:    "compare",
	Short:  "Build comparisons for macro against index",
	Long:   "Build comparisons for macro against index",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if compareMacroId == 0 {
			Env.Fatalln("Macro id is required")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.Compare(Env, int64(compareMacroId))
	},
}

var CoverAspectCmd = &cobra.Command{
	Use:    "cover_aspect",
	Short:  "Create a aspect cover",
	Long:   "Create a aspect cover",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if coverAspectWidth == 0 {
			Env.Fatalln("width is required")
		} else if coverAspectWidth < 0 {
			Env.Fatalln("width must be greater than zero")
		}

		if coverAspectHeight == 0 {
			Env.Fatalln("height is required")
		} else if coverAspectHeight < 0 {
			Env.Fatalln("height must be greater than zero")
		}

		if coverAspect == "" {
			Env.Fatalln("aspect is required")
		}

		aspectStrings := strings.Split(coverAspect, "x")
		if len(aspectStrings) != 2 {
			Env.Fatalln("aspect format must be CxR")
		}

		aw, err := strconv.Atoi(aspectStrings[0])
		if err != nil {
			Env.Fatalf("Error converting aspect columns: %s\n", err.Error())
		}

		if aw == 0 {
			Env.Fatalln("aspect columns cannot be zero")
		} else if aw < 0 {
			Env.Fatalln("aspect columns must be greater than zero")
		}

		ah, err := strconv.Atoi(aspectStrings[1])
		if err != nil {
			Env.Fatalf("Error converting aspect rows: %s\n", err.Error())
		}

		if ah == 0 {
			Env.Fatalln("aspect rows cannot be zero")
		} else if ah < 0 {
			Env.Fatalln("aspect rows must be greater than zero")
		}

		if coverAspectSize == 0 {
			Env.Fatalln("num is required")
		} else if coverAspectSize < 0 {
			Env.Fatalln("num must be greater than zero")
		}

		err = Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.CoverAspect(Env, coverAspectWidth, coverAspectHeight, aw, ah, coverAspectSize)
	},
}

var CoverDrawCmd = &cobra.Command{
	Use:    "cover_draw PATH",
	Short:  "Draw a cover image",
	Long:   "Draw a cover image",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("Path is required")
		}

		if coverDrawId == 0 {
			Env.Fatalln("cover id is required")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		ext := strings.ToLower(filepath.Ext(args[0]))
		if ext != ".png" {
			Env.Fatalf("Out path must be a .png file")
		}

		controller.CoverDraw(Env, int64(coverDrawId), args[0])
	},
}

var CoverListCmd = &cobra.Command{
	Use:    "cover_list",
	Short:  "List cover entries",
	Long:   "List cover entries",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.CoverList(Env)
	},
}

var CoverRmCmd = &cobra.Command{
	Use:    "cover_rm NAMES...",
	Short:  "Remove cover entries",
	Long:   "Remove cover entries",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.CoverRm(Env, args)
	},
}

var IndexCmd = &cobra.Command{
	Use:   "index [PATHS...]",
	Short: "Manage index images",
	Long:  "Manage index images",
	Run: func(c *cobra.Command, args []string) {
		paths := make([]string, 0)
		if len(args) > 0 {
			paths = append(paths, args...)
		}

		stat, _ := os.Stdin.Stat()
		if (stat.Mode() & os.ModeCharDevice) == 0 {
			b, err := ioutil.ReadAll(os.Stdin)
			if err != nil {
				Env.Fatalf("Unable to read from stdin")
			}

			inPaths := strings.Split(string(b), "\n")
			for _, inp := range inPaths {
				if inp != "" {
					paths = append(paths, inp)
				}
			}
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		if indexClean {

			if len(paths) != 0 {
				Env.Fatalln("Cannot specify paths with index clean")
			}
			_, err = controller.IndexClean(Env)
			if err != nil {
				Env.Printf("Error cleaning index: %s\n", err.Error())
			}
		} else if indexList {

			if len(paths) != 0 {
				Env.Fatalln("Cannot specify paths with index list")
			}
			err = controller.IndexList(Env)
			if err != nil {
				Env.Printf("Error listing index: %s\n", err.Error())
			}
		} else if indexRm {

			if len(paths) == 0 {
				Env.Fatalln("Must specify paths to rm from index")
			}
			err = controller.IndexRm(Env, paths)
			if err != nil {
				Env.Printf("Error removing index images: %s\n", err.Error())
			}
		} else {

			if len(paths) == 0 {
				Env.Fatalln("Must specify paths to index")
			}
			err = controller.Index(Env, paths)
			if err != nil {
				Env.Printf("Error adding index images: %s\n", err.Error())
			}
		}
	},
}

var MacroAspectCmd = &cobra.Command{
	Use:    "macro_aspect PATH",
	Short:  "Add cover aspect and macro",
	Long:   "Add cover aspect and macro",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("PATH is required")
		}

		if args[0] == "" {
			Env.Fatalln("Macro path is required")
		}

		if macroAspectWidth < 0 {
			Env.Fatalln("width must be greater than zero")
		}

		if macroAspectHeight < 0 {
			Env.Fatalln("height must be greater than zero")
		}

		if macroAspect == "" {
			Env.Fatalln("aspect is required")
		}

		aspectStrings := strings.Split(macroAspect, "x")
		if len(aspectStrings) != 2 {
			Env.Fatalln("aspect format must be CxR")
		}

		aw, err := strconv.Atoi(aspectStrings[0])
		if err != nil {
			Env.Fatalf("Error converting aspect columns: %s\n", err.Error())
		}

		if aw == 0 {
			Env.Fatalln("aspect columns cannot be zero")
		} else if aw < 0 {
			Env.Fatalln("aspect columns must be greater than zero")
		}

		ah, err := strconv.Atoi(aspectStrings[1])
		if err != nil {
			Env.Fatalf("Error converting aspect rows: %s\n", err.Error())
		}

		if ah == 0 {
			Env.Fatalln("aspect rows cannot be zero")
		} else if ah < 0 {
			Env.Fatalln("aspect rows must be greater than zero")
		}

		if macroAspectSize == 0 {
			Env.Fatalln("num is required")
		} else if macroAspectSize < 0 {
			Env.Fatalln("num must be greater than zero")
		}

		err = Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MacroAspect(Env, args[0], macroAspectWidth, macroAspectHeight, aw, ah, macroAspectSize, macroAspectCoverOutfile, macroAspectMacroOutfile)
	},
}

var MacroCmd = &cobra.Command{
	Use:    "macro PATH",
	Short:  "Add macro",
	Long:   "Add macro",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("Macro path is required")
		}

		if args[0] == "" {
			Env.Fatalln("Macro path is required")
		}

		if macroCoverId == 0 {
			Env.Fatalln("Cover id is required")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.Macro(Env, args[0], int64(macroCoverId), macroOutfile)
	},
}

var MacroListCmd = &cobra.Command{
	Use:    "macro_list",
	Short:  "List macro entries",
	Long:   "List macro entries",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MacroList(Env)
	},
}

var MacroQuadCmd = &cobra.Command{
	Use:    "macro_quad PATH",
	Short:  "Add quad cover and macro",
	Long:   "Add quad cover and macro",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("PATH is required")
		}

		if args[0] == "" {
			Env.Fatalln("Macro path is required")
		}

		if macroQuadWidth < 0 {
			Env.Fatalln("width must be greater than zero")
		}

		if macroQuadHeight < 0 {
			Env.Fatalln("height must be greater than zero")
		}

		if macroQuadSize == 0 &&
			macroQuadMinDepth == 0 &&
			macroQuadMaxDepth == 0 &&
			macroQuadMinArea == 0 &&
			macroQuadMaxArea == 0 {
			Env.Fatalln("Add least one of size, min-depth, max-depth, min-area, or max-area must be non-zero.")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MacroQuad(
			Env,
			args[0],
			macroQuadWidth,
			macroQuadHeight,
			macroQuadSize,
			macroQuadMinDepth,
			macroQuadMaxDepth,
			macroQuadMinArea,
			macroQuadMaxArea,
			macroQuadCoverOutfile,
			macroQuadMacroOutfile,
		)
	},
}

var MosaicAspectCmd = &cobra.Command{
	Use:   "aspect PATH",
	Short: "Create an aspect mosaic from image at PATH",
	Long:  "Create an aspect mosaic from image at PATH",
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("Mosaic path is required")
		}

		if args[0] == "" {
			Env.Fatalln("Mosaic path is required")
		}

		if mosaicAspectCoverWidth < 0 {
			Env.Fatalln("width must be greater than zero")
		}

		if mosaicAspectCoverHeight < 0 {
			Env.Fatalln("height must be greater than zero")
		}

		var (
			aw, ah int
			err    error
		)

		if mosaicAspectPartialAspect == "" {
			aw = 0
			ah = 0
		} else {
			aspectStrings := strings.Split(mosaicAspectPartialAspect, "x")
			if len(aspectStrings) != 2 {
				Env.Fatalln("aspect format must be CxR")
			}

			aw, err = strconv.Atoi(aspectStrings[0])
			if err != nil {
				Env.Fatalf("Error converting aspect columns: %s\n", err.Error())
			}

			if aw < 0 {
				Env.Fatalln("aspect columns must be greater than zero")
			}

			ah, err = strconv.Atoi(aspectStrings[1])
			if err != nil {
				Env.Fatalf("Error converting aspect rows: %s\n", err.Error())
			}

			if ah < 0 {
				Env.Fatalln("aspect rows must be greater than zero")
			}
		}

		if mosaicAspectFillType != "best" && mosaicAspectFillType != "random" {
			Env.Fatalln("Invalid fill-type")
		}

		err = Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MosaicAspect(
			Env,
			args[0],
			mosaicAspectName,
			mosaicAspectFillType,
			mosaicAspectCoverWidth,
			mosaicAspectCoverHeight,
			aw,
			ah,
			mosaicAspectSize,
			mosaicAspectMaxRepeats,
			mosaicAspectThreashold,
			mosaicAspectCoverOutfile,
			mosaicAspectMacroOutfile,
			mosaicAspectOutfile,
			mosaicAspectCleanup,
			mosaicAspectDestructive,
		)
	},
}

var MosaicBuildCmd = &cobra.Command{
	Use:    "mosaic_build NAME",
	Short:  "Build mosaic",
	Long:   "Build mosaic",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if mosaicBuildMacroId == 0 {
			Env.Fatalln("Macro id is required")
		}

		if mosaicBuildFillType != "best" && mosaicBuildFillType != "random" {
			Env.Fatalln("type must be either 'best' or 'random'")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MosaicBuild(Env, mosaicBuildFillType, int64(mosaicBuildMacroId), mosaicBuildMaxRepeats, mosaicBuildDestructive)
	},
}

var MosaicCmd = &cobra.Command{
	Use:   "mosaic",
	Short: "Create a mosaic",
	Long:  "Create a mosaic",
}

var MosaicDrawCmd = &cobra.Command{
	Use:    "mosaic_draw OUTFILE",
	Short:  "Draw mosaic",
	Long:   "Draw mosaic",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("Mosaic out file is required")
		}

		if args[0] == "" {
			Env.Fatalln("Mosaic out file is required")
		}

		if mosaicDrawMosaicId == 0 {
			Env.Fatalln("Mosaic id is required")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MosaicDraw(Env, int64(mosaicDrawMosaicId), args[0])
	},
}

var MosaicListCmd = &cobra.Command{
	Use:    "mosaic_list",
	Short:  "List mosaic entries",
	Long:   "List mosaic entries",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MosaicList(Env)
	},
}

var MosaicQuadCmd = &cobra.Command{
	Use:   "quad PATH",
	Short: "Create quad-tree mosaic from image at PATH",
	Long:  "Create quad-tree mosaic from image at PATH",
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("Mosaic path is required")
		}

		if args[0] == "" {
			Env.Fatalln("Mosaic path is required")
		}

		if mosaicQuadCoverWidth < 0 {
			Env.Fatalln("width must be greater than zero")
		}

		if mosaicQuadCoverHeight < 0 {
			Env.Fatalln("height must be greater than zero")
		}

		if mosaicQuadFillType != "best" && mosaicAspectFillType != "random" {
			Env.Fatalln("Invalid fill-type")
		}

		if mosaicQuadSize == 0 &&
			mosaicQuadMinDepth == 0 &&
			mosaicQuadMaxDepth == 0 &&
			mosaicQuadMinArea == 0 &&
			mosaicQuadMaxArea == 0 {
			Env.Fatalln("Add least one of size, min-depth, max-depth, min-area, or max-area must be non-zero.")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MosaicQuad(
			Env,
			args[0],
			mosaicQuadName,
			mosaicQuadFillType,
			mosaicQuadCoverWidth,
			mosaicQuadCoverHeight,
			mosaicQuadSize,
			mosaicQuadMinDepth,
			mosaicQuadMaxDepth,
			mosaicQuadMinArea,
			mosaicQuadMaxArea,
			mosaicQuadMaxRepeats,
			mosaicQuadThreashold,
			mosaicQuadCoverOutfile,
			mosaicQuadMacroOutfile,
			mosaicQuadOutfile,
			mosaicQuadCleanup,
			mosaicQuadDestructive,
		)
	},
}

var PartialAspectCmd = &cobra.Command{
	Use:    "partial_aspect",
	Short:  "Build partial aspects for indexed images",
	Long:   "Build partial aspects for indexed images",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		if partialAspectMacroId == 0 {
			Env.Fatalf("Macro id is required")
		}

		controller.PartialAspect(Env, int64(partialAspectMacroId), partialAspectThreashold)
	},
}

var StatusCmd = &cobra.Command{
	Use:   "status",
	Short: "Show environment status",
	Long:  "Show environment status",
	Run: func(c *cobra.Command, args []string) {
		err := Env.Init()
		if err != nil {
			fmt.Printf("Unable to initialize environment: %s\n", err.Error())
			os.Exit(1)
		}
		defer Env.Close()

		controller.Status(Env)
	},
}

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: "Print the version number and exit",
	Long:  "Print the version number and exit",
	Run: func(c *cobra.Command, args []string) {
		fmt.Printf("gosaic %s (%s) %s %s\n",
			environment.Version,
			environment.BuildTime,
			environment.BuildUser,
			environment.BuildHash)
	},
}