func downloadImage(url string) (string, error) {
	tmpFile, err := openTempFile()
	if err != nil {
		return "", err
	}
	defer tmpFile.Close()

	res, err := http.Get(url)
	if err != nil {
		return "", err
	}
	defer res.Body.Close()
	if res.StatusCode < 200 || res.StatusCode >= 300 {
		return "", errors.New("non-200 status code")
	}

	_, err = io.Copy(tmpFile, res.Body)
	if err != nil {
		return "", err
	}

	return tmpFile.Name(), nil
}

func changeWallpaper(schedule Schedule) error {
	sig := time.Now().Unix()
	url := fmt.Sprintf("%s?sig=%d", baseURL, sig)
	if schedule.Keywords != "" {
		url = fmt.Sprintf("%s&%s", url, schedule.Keywords)
	}
	imagePath, err := downloadImage(url)
	if err != nil {
		log.Println(err)
		return err
	}
	if err := wallpaper.SetFromFile(imagePath); err != nil {
		log.Println(err)
		return err
	}
	return nil
}

var err error
if schedules, err = parseScheduleConfig(configFilePath); err != nil {
    log.Fatalln(err)
}
table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Schedule", "Keyword", "Description"})

ctab := crontab.New()
for _, job := range schedules {
    ctab.MustAddJob(job.Schedule, changeWallpaper, job)
    table.Append([]string{job.Schedule, job.Keywords, job.Description})
}
table.Render()

func handleServiceAction(serviceAction string) {
	if serviceAction != "" {
		srv, err := daemon.New(name, description)
		if err != nil {
			log.Println("Error: ", err)
			os.Exit(1)
		}
		service := &Service{srv}
		var status string

		switch serviceAction {
		case "install":
			args := []string{
				"--deamon",
			}
			for _, arg := range os.Args[1:] {
				if strings.Index(arg, "--service=") == -1 {
					args = append(args, arg)
				}
			}
			status, err = service.Install(args...)
		case "remove":
			status, err = service.Remove()
		case "start":
			status, err = service.Start()
		case "stop":
			status, err = service.Stop()
		case "status":
			status, err = service.Status()
		default:
			status = "Usage: awesome-wallpaper service install | remove | start | stop | status"
			os.Exit(0)
		}
		if err != nil {
			log.Fatalln(err)
		}
		log.Println(status)
		os.Exit(0)
	}
}

interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)
killSignal := <-interrupt
log.Println("Got signal:", killSignal)
if killSignal == os.Interrupt {
    log.Println("Interruped by system signal ")
}
log.Println("Bye...")

func main() {
	var (
		schedule       string
		keywords       string
		configFilePath string
		serviceAction  string
		showVersion    bool
		showHelp       bool
		isDeamon       bool
	)

	flag.BoolVar(&showVersion, "version", false, fmt.Sprintf("Current version: %s", version))
	flag.BoolVar(&showHelp, "help", false, "View help message")
	flag.StringVar(&schedule, "schedule", "30 * * * *", "(optional) A crontab-like syntax schedule")
	flag.StringVar(&keywords, "keywords", "", "(optional) Keyword to search for image")
	flag.StringVar(&configFilePath, "conf", "", "(optional) Config file path")
	flag.StringVar(&serviceAction, "service", "", "(optional) Action about services: install, uninstall, remove, stop, status")
	flag.BoolVar(&isDeamon, "deamon", false, "(optional) Indicate if program is running as deamon")
	flag.Parse()

	if showHelp {
		flag.PrintDefaults()
		os.Exit(0)
	}

	if showVersion {
		log.Printf("awesome-wallpaper %s\n", version)
		os.Exit(0)
	}

	handleServiceAction(serviceAction)
	setupLogger(isDeamon)

	var schedules []Schedule
	if configFilePath != "" {
		var err error
		if schedules, err = parseScheduleConfig(configFilePath); err != nil {
			log.Fatalln(err)
		}
	} else {
		schedules = []Schedule{
			{
				Schedule: schedule,
				Keywords: keywords,
			},
		}
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"Schedule", "Keyword", "Description"})

	ctab := crontab.New()
	for _, job := range schedules {
		ctab.MustAddJob(job.Schedule, changeWallpaper, job)
		table.Append([]string{job.Schedule, job.Keywords, job.Description})
	}
	table.Render()

	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)

	log.Println("Running...")

	killSignal := <-interrupt
	log.Println("Got signal:", killSignal)
	if killSignal == os.Interrupt {
		log.Println("Interruped by system signal ")
	}
	log.Println("Bye...")
}