func getItems(config yaml.File, key string) ([]*AvailableBlock, error) {
	lst, err := validateItems(config, key)
	if err != nil {
		return nil, errors.New("Invalid items")
	}
	items := make([]*AvailableBlock, lst.Len())
	for i, e := range lst {
		itemKey := key + "[" + strconv.Itoa(i) + "]"
		title, err := config.Get(itemKey + ".title")
		if err != nil {
			return nil, errors.New("Missing title")
		}
		series, err := config.Get(itemKey + ".series")
		if err != nil {
			series = ""
		}
		filepathsNode, err := yaml.Child(e, "filepaths")
		if err != nil {
			return nil, errors.New("Missing filepaths for " + title)
		}
		publish := true
		if key == "extras" {
			publish = false
		}
		items[i] = new(AvailableBlock).Init(title, series, filepathsNode.(yaml.List), publish)
	}
	return items, nil
}

func YamlList2Slice(config *yaml.File, text string) []string {
	count, err := config.Count(text)
	if err != nil {
		loge.Error(err)
		return nil
	}

	var result []string
	for i := 0; i < count; i++ {
		v, err := config.Get(text + "[" + strconv.Itoa(i) + "]")
		if err != nil {
			loge.Error(err)
			return nil
		}
		result = append(result, v)
	}
	return result
}

func YamlList2String(config *yaml.File, text string) string {
	count, err := config.Count(text)
	if err != nil {
		log.Println(err)
		return ""
	}

	var resultGroup []string
	for i := 0; i < count; i++ {
		v, err := config.Get(text + "[" + strconv.Itoa(i) + "]")
		if err != nil {
			log.Println(err)
			return ""
		}
		resultGroup = append(resultGroup, v)
	}

	result := strings.Join(resultGroup, "\n")
	result = strings.Replace(result, "\\n", "", -1)

	return result
}

// Creates a new SQLConf and returns a pointer to it.
// If it encounters an error during parsing the file,
// it will return an error instead.
func confFromYamlFile(config *yaml.File, goEnv string) (*SQLConf, error) {

	// TODO Refactor this into a more generic method of retrieving info

	// Get driver
	driver, driveError := config.Get(fmt.Sprintf("%s.driver", goEnv))
	if driveError != nil {
		return nil, driveError
	}

	// Get openStr
	openStr, openStrError := config.Get(fmt.Sprintf("%s.openStr", goEnv))
	if openStrError != nil {
		return nil, openStrError
	}

	// Get table
	table, tableError := config.Get(fmt.Sprintf("%s.table", goEnv))
	if tableError != nil {
		return nil, tableError
	}

	// Get latCol
	latCol, latColError := config.Get(fmt.Sprintf("%s.latCol", goEnv))
	if latColError != nil {
		return nil, latColError
	}

	// Get lngCol
	lngCol, lngColError := config.Get(fmt.Sprintf("%s.lngCol", goEnv))
	if lngColError != nil {
		return nil, lngColError
	}

	sqlConf := &SQLConf{driver: driver, openStr: openStr, table: table, latCol: latCol, lngCol: lngCol}
	return sqlConf, nil

}

func ParseConfig(config *yaml.File) (*Config, error) {
	base, err := config.Get("base")
	if err != nil {
		return nil, err
	}
	var rpm *RpmPackage = nil
	rpmBaseNode, err := yaml.Child(config.Root, "rpm-base")
	if err != nil {
		return nil, err
	}
	if rpmBaseNode != nil {
		rpmBaseMap := rpmBaseNode.(yaml.Map)
		scalar := rpmBaseMap["name"].(yaml.Scalar)
		name := strings.TrimSpace(scalar.String())
		scalar = rpmBaseMap["version"].(yaml.Scalar)
		version := strings.TrimSpace(scalar.String())
		scalar = rpmBaseMap["release"].(yaml.Scalar)
		release := strings.TrimSpace(scalar.String())
		scalar = rpmBaseMap["arch"].(yaml.Scalar)
		arch := strings.TrimSpace(scalar.String())
		rpm = &RpmPackage{
			Name:    name,
			Version: version,
			Release: release,
			Arch:    arch,
		}
	}
	cmdline, err := config.Get("cmdline")
	if err != nil {
		return nil, err
	}
	build, _ := config.Get("build")
	filesNode, err := yaml.Child(config.Root, "files")
	if err != nil {
		return nil, err
	}
	files := make(map[string]string)
	if filesNode != nil {
		filesMap := filesNode.(yaml.Map)
		for key, value := range filesMap {
			scalar := value.(yaml.Scalar)
			files[key] = strings.TrimSpace(scalar.String())
		}
	}
	result := &Config{
		Base:    base,
		RpmBase: rpm,
		Cmdline: cmdline,
		Build:   build,
		Files:   files,
	}
	return result, nil
}

func extractConnectionOptions(config *yaml.File) (connectionOptions pgx.ConnectionParameters, err error) {
	connectionOptions.Host, _ = config.Get("database.host")
	connectionOptions.Socket, _ = config.Get("database.socket")
	if connectionOptions.Host == "" && connectionOptions.Socket == "" {
		err = errors.New("Config must contain database.host or database.socket but it does not")
		return
	}
	port, _ := config.GetInt("database.port")
	connectionOptions.Port = uint16(port)
	if connectionOptions.Database, err = config.Get("database.database"); err != nil {
		err = errors.New("Config must contain database.database but it does not")
		return
	}
	if connectionOptions.User, err = config.Get("database.user"); err != nil {
		err = errors.New("Config must contain database.user but it does not")
		return
	}
	connectionOptions.Password, _ = config.Get("database.password")
	return
}

func init() {
	var err error
	var yf *yaml.File

	flag.StringVar(&config.listenAddress, "address", "127.0.0.1", "address to listen on")
	flag.StringVar(&config.listenPort, "port", "8080", "port to listen on")
	flag.StringVar(&config.assetPath, "assetpath", "assets", "path to assets")
	flag.StringVar(&config.configPath, "config", "config.yml", "path to config file")
	flag.Parse()

	givenCliArgs := make(map[string]bool)
	flag.Visit(func(f *flag.Flag) {
		givenCliArgs[f.Name] = true
	})

	if config.configPath, err = filepath.Abs(config.configPath); err != nil {
		fmt.Fprintf(os.Stderr, "Invalid config path: %v\n", err)
		os.Exit(1)
	}

	if config.assetPath, err = filepath.Abs(config.assetPath); err != nil {
		fmt.Fprintf(os.Stderr, "Invalid asset path: %v\n", err)
		os.Exit(1)
	}

	if yf, err = yaml.ReadFile(config.configPath); err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(1)
	}

	if !givenCliArgs["address"] {
		if address, err := yf.Get("address"); err == nil {
			config.listenAddress = address
		}
	}

	if !givenCliArgs["assetpath"] {
		if assetpath, err := yf.Get("assetpath"); err == nil {
			config.assetPath = assetpath
		}
	}

	if !givenCliArgs["port"] {
		if port, err := yf.Get("port"); err == nil {
			config.listenPort = port
		}
	}

	var connectionParameters pgx.ConnectionParameters
	if connectionParameters, err = extractConnectionOptions(yf); err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(1)
	}

	if err = migrate(connectionParameters); err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(1)
	}

	poolOptions := pgx.ConnectionPoolOptions{MaxConnections: 5, AfterConnect: afterConnect}
	pool, err = pgx.NewConnectionPool(connectionParameters, poolOptions)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Unable to create database connection pool: %v\n", err)
		os.Exit(1)
	}
}