// LoadConfig loads the config into the Config Struct and returns the // ConfigStruct object. Will load from environmental variables (all caps) if we
// set a flag to true.
func LoadConfig() ConfigStruct {
	viper.SetConfigName("config")
	viper.SetConfigType("yaml")
	viper.AddConfigPath(".")
	viper.AddConfigPath("../")
	viper.AddConfigPath("/etc/")
	viper.AddConfigPath("$GOPATH/src/github.com/GrappigPanda/notorious/")

	err := viper.ReadInConfig()
	if err != nil {
		panic("Failed to open config file")
	}

	if viper.GetBool("UseEnvVariables") == true {
		viper.AutomaticEnv()
		viper.BindEnv("dbuser")
	}

	whitelist, err := strconv.ParseBool(viper.Get("whitelist").(string))
	if err != nil {
		whitelist = false
	}

	return loadSQLOptions(whitelist)
}

func main() {
	config.LoadConfig()
	dev := viper.Sub("app.development.twitter")
	fmt.Println(dev)
	fmt.Println(dev.Get("consumerKey"))

	consumerKey := viper.Get("app.development.twitter.consumerKey").(string)
	consumerSecret := viper.Get("app.development.twitter.consumerSecret").(string)
	tokenKey := viper.Get("app.development.twitter.token").(string)
	tokenSecret := viper.Get("app.development.twitter.tokenSecret").(string)

	config := oauth1.NewConfig(consumerKey, consumerSecret)
	token := oauth1.NewToken(tokenKey, tokenSecret)
	httpClient := config.Client(oauth1.NoContext, token)

	client := twitter.NewClient(httpClient)

	userShowParams := &twitter.UserShowParams{ScreenName: "realDonaldTrump"}
	user, _, _ := client.Users.Show(userShowParams)
	fmt.Printf("USERS SHOW:\n%v\n", user)

	f := new(bool)
	*f = false
	userTimelineParams := &twitter.UserTimelineParams{ScreenName: "realDonaldTrump", Count: 1, IncludeRetweets: f}
	tweets, _, _ := client.Timelines.UserTimeline(userTimelineParams)
	for tweet := range tweets {
		t, _ := json.MarshalIndent(tweets[tweet], "", "    ")
		fmt.Println(string(t))
	}
}

// GetConfig return configuration instance
func GetConfig() Config {
	config := Config{
		LinguaLeo: linguaLeo{
			Email:    cast.ToString(viper.Get("lingualeo.email")),
			Password: cast.ToString(viper.Get("lingualeo.password")),
		},
	}
	return config
}

func main() {
	redmine := redmine.New(
		viper.GetString("redmine.url"),
		viper.GetString("redmine.api_key"),
		cast.ToIntSlice(viper.Get("redmine.closed_statuses")),
		cast.ToIntSlice(viper.Get("redmine.high_priorities")),
	)
	slack := slack.New(redmine, viper.GetString("slack.token"))

	slack.Listen()
}

// initConfig reads in config file and ENV variables if set.
func initConfig() {
	mutex.Lock()
	if cfgFile != "" {
		// enable ability to specify config file via flag
		viper.SetConfigFile(cfgFile)
	}

	path := absPathify("$HOME")
	if _, err := os.Stat(filepath.Join(path, ".hydra.yml")); err != nil {
		_, _ = os.Create(filepath.Join(path, ".hydra.yml"))
	}

	viper.SetConfigType("yaml")
	viper.SetConfigName(".hydra") // name of config file (without extension)
	viper.AddConfigPath("$HOME")  // adding home directory as first search path
	viper.AutomaticEnv()          // read in environment variables that match

	// If a config file is found, read it in.
	if err := viper.ReadInConfig(); err != nil {
		fmt.Printf(`Config file not found because "%s"`, err)
		fmt.Println("")
	}

	if err := viper.Unmarshal(c); err != nil {
		fatal("Could not read config because %s.", err)
	}

	if consentURL, ok := viper.Get("CONSENT_URL").(string); ok {
		c.ConsentURL = consentURL
	}

	if clientID, ok := viper.Get("CLIENT_ID").(string); ok {
		c.ClientID = clientID
	}

	if systemSecret, ok := viper.Get("SYSTEM_SECRET").(string); ok {
		c.SystemSecret = []byte(systemSecret)
	}

	if clientSecret, ok := viper.Get("CLIENT_SECRET").(string); ok {
		c.ClientSecret = clientSecret
	}

	if databaseURL, ok := viper.Get("DATABASE_URL").(string); ok {
		c.DatabaseURL = databaseURL
	}

	if c.ClusterURL == "" {
		fmt.Printf("Pointing cluster at %s\n", c.GetClusterURL())
	}
	mutex.Unlock()
}

func getTestMenuState(s *Site, t *testing.T) *testMenuState {
	menuState := &testMenuState{site: s, oldBaseURL: viper.Get("baseurl"), oldMenu: viper.Get("menu")}

	menus, err := tomlToMap(CONF_MENU1)

	if err != nil {
		t.Fatalf("Unable to Read menus: %v", err)
	}

	viper.Set("menu", menus["menu"])
	viper.Set("baseurl", "http://foo.local/Zoo/")

	return menuState
}

func loadSQLOptions(whitelist bool) ConfigStruct {
	var sqlDeployOption string
	if viper.GetBool("UseMySQL") {
		sqlDeployOption = "mysql"
	} else {
		sqlDeployOption = "postgres"
	}

	var ircCfg *IRCConfig
	if viper.GetBool("UseIRCNotify") {
		ircCfg = loadIRCOptions()
	} else {
		ircCfg = nil
	}

	var useRSS bool
	if viper.GetBool("UseRSSNotify") {
		useRSS = true
	} else {
		useRSS = false
	}

	if viper.Get("dbpass").(string) != "" {
		return ConfigStruct{
			sqlDeployOption,
			viper.Get("dbhost").(string),
			viper.Get("dbport").(string),
			viper.Get("dbuser").(string),
			viper.Get("dbpass").(string),
			viper.Get("dbname").(string),
			whitelist,
			ircCfg,
			useRSS,
		}
	} else {
		return ConfigStruct{
			sqlDeployOption,
			viper.Get("dbhost").(string),
			viper.Get("dbport").(string),
			viper.Get("dbuser").(string),
			"",
			viper.Get("dbname").(string),
			whitelist,
			ircCfg,
			useRSS,
		}
	}
}

func loadBundles() {
	target := viper.GetString("WorkingDir")

	tdir := filepath.Join(target, "bundles")

	if _, err := os.Stat(tdir); os.IsNotExist(err) {
		return
	}

	bund := viper.Get("Bundles").([]Bundle)
	filepath.Walk(tdir, func(path string, f os.FileInfo, err error) error {
		name := filepath.Base(path)

		if name == "bundles" {
			return nil
		}

		rpath, _ := filepath.Rel(target, path)
		if s, _ := os.Stat(path); s.IsDir() {
			bund = append(bund, Bundle{name, rpath})
		}
		return nil
	})

	viper.Set("Bundles", bund)
}

// Config returns the currently active Hugo config. This will be set
// per site (language) rendered.
func Config() ConfigProvider {
	if currentConfigProvider != nil {
		return currentConfigProvider
	}
	// Some tests rely on this. We will fix that, eventually.
	return viper.Get("currentContentLanguage").(ConfigProvider)
}

func (suite *GitConfigTestSuite) SetupTest() {
	assert := assert.New(suite.T())
	viper.SetConfigFile("../../.ayi.example.yml")
	err := viper.ReadInConfig()
	assert.Nil(err)
	assert.Equal(true, viper.Get("debug"))
}

func (this *RedisStore) DeactivateLongpollKillswitch() error {
	killswitchKey := viper.Get("longpoll_killswitch")

	return this.redisPendingQueue.RunAsyncTimeout(5*time.Second, func(conn redis.Conn) (result interface{}, err error) {
		return conn.Do("DEL", killswitchKey)
	}).Error
}

// ViperGetStringOrFail returns string without any convertion
// FIXED: https://github.com/dyweb/Ayi/issues/54
func ViperGetStringOrFail(key string) (string, error) {
	v := viper.Get(key)
	s, ok := v.(string)
	if ok {
		return s, nil
	}
	return "", errors.Errorf("%v is not a string", v)
}

func loadBoolPtr(key string) *bool {
	val := viper.Get(key)
	if val == nil {
		return nil
	}
	b := viper.GetBool(key)
	return &b
}

func loadConfig(c *Config) {
	err := viper.ReadInConfig() // Find and read the config file
	if err != nil {             // Handle errors reading the config file
		log.Error("Fatal error config file.", "error", err)
	} else {
		c.Alert = viper.Get("alert")
	}

}

func (s *Site) initializeSiteInfo() {
	params, ok := viper.Get("Params").(map[string]interface{})
	if !ok {
		params = make(map[string]interface{})
	}

	permalinks, ok := viper.Get("Permalinks").(PermalinkOverrides)
	if !ok {
		permalinks = make(PermalinkOverrides)
	}

	s.Info = SiteInfo{
		BaseUrl:    template.URL(helpers.SanitizeUrl(viper.GetString("BaseUrl"))),
		Title:      viper.GetString("Title"),
		Recent:     &s.Pages,
		Params:     params,
		Permalinks: permalinks,
	}
}

func (l *Language) Get(key string) interface{} {
	if l == nil {
		panic("language not set")
	}
	key = strings.ToLower(key)
	if v, ok := l.params[key]; ok {
		return v
	}
	return viper.Get(key)
}

func deleteProduct(d Delete) {
	if d.SKU == "" {
		return
	}
	user := viper.Get("User")
	stmt, err := db.Prepare("DELETE FROM products WHERE SKU=? AND User=?")
	errHandle(err)
	_, err = stmt.Exec(d.SKU, user)
	errHandle(err)
}

func Update(coreOnly bool, securityOnly bool, checkDisabled bool) (result interface{}, err error) {
	switch viper.Get("app_type") {
	case "drupal":
		result, err = drupalUpdate(coreOnly, securityOnly, checkDisabled)
	case "wpress":
		result, err = wpressUpdate(coreOnly)
	default:
		result, err = nil, errors.New("Not implemented", 0)
	}

	return result, err
}

func Revert() (result interface{}, err error) {
	switch viper.Get("app_type") {
	case "drupal":
		result, err = drupalRevert()
		//	case "wpress":
		//		result, err = wpressMigrate()
	default:
		result, err = nil, errors.New("Not implemented", 0)
	}

	return result, err
}

// getDateFormat gets the dateFormat value from Params. The dateFormat should
// be a valid time layout. If it isn't set, time.RFC3339 is used.
func getDateFormat() string {
	params := viper.Get("params")
	if params == nil {
		return time.RFC3339
	}
	parms := params.(map[interface{}]interface{})
	layout := parms["DateFormat"]
	if layout == nil || layout == "" {
		return time.RFC3339
	}
	return layout.(string)
}