summary refs log tree commit diff stats
path: root/cmd/cetus-wallhaven/cetus-wallhaven.go
blob: 8c6c92809764b28cfb2ac2c036fa7eaa21986d50 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"math/rand"
	"time"

	"framagit.org/andinus/cetus/pkg/background"
	"framagit.org/andinus/cetus/pkg/cetus"
	"framagit.org/andinus/cetus/pkg/wallhaven"
)

type wh struct {
	Photos []photo `json:"data"`
	// MetaI  []meta  `json:"meta"`
}

// type meta struct {
// 	CurrentPage int    `json:"current_page"`
// 	LastPage    int    `json:"last_page"`
// 	PerPage     int    `json:"per_page"`
// 	Total       int    `json:"total"`
// 	Query       string `json:"query"`
// 	Seed        string `json:"seed"`
// }

type photo struct {
	Id         string   `json:"id"`
	Url        string   `json:"url"`
	ShortUrl   string   `json:"short_url"`
	Views      int      `json:"views"`
	Favorites  int      `json:"favorites"`
	Source     string   `json:"source"`
	Purity     string   `json:"purity"`
	Category   string   `json:"category"`
	DimensionX int      `json:"dimension_x"`
	DimensionY int      `json:"dimension_y"`
	Resolution string   `json:"resolution"`
	Ratio      string   `json:"ratio"`
	FileSize   int      `json:"file_size"`
	FileType   string   `json:"file_type"`
	CreatedAt  string   `json:"created_at"`
	Path       string   `json:"path"`
	Colors     []string `json:"colors"`
	// Thumbs     []thumb  `json:"thumbs"`
}

// type thumb struct {
// 	Small    string `json:"small"`
// 	Original string `json:"original"`
// 	Large    string `json:"large"`
// }

var (
	t         time.Duration
	api       string
	apiKey    string
	dump      bool
	quiet     bool
	random    bool
	version   bool
	pathOnly  bool
	fetchOnly bool
)

func main() {
	parseFlags()

	if version {
		cetus.Version()
		return
	}
	rand.Seed(time.Now().Unix())

	// Convert timeout to seconds
	t = t * time.Second

	body, err := whBody()
	if dump {
		fmt.Println(body)
		return
	}

	wh := wh{}
	err = json.Unmarshal([]byte(body), &wh)
	cetus.ErrChk("body unmarshal failed", err)

	// if random was set then wh holds list of multiple responses,
	// choose a random response from the list
	i := rand.Intn(len(wh.Photos))
	whPhoto := wh.Photos[i]

	printDetails(whPhoto)

	// if fetchOnly is true then don't set background
	if fetchOnly {
		return
	}

	err = background.Set(whPhoto.Path)
	cetus.ErrChk("setting background failed", err)
}

func parseFlags() {
	flag.BoolVar(&quiet, "quiet", false, "No output")
	flag.BoolVar(&version, "version", false, "Cetus version")
	flag.BoolVar(&fetchOnly, "fetch-only", false, "Don't set background, only fetch info")
	flag.BoolVar(&dump, "dump", false, "Only dump received response")
	flag.BoolVar(&random, "random", true, "Choose a random image")
	flag.BoolVar(&pathOnly, "path-only", false, "Print only path of the image")

	flag.StringVar(&api, "api", "https://wallhaven.cc/api/v1/search", "Wallhaven Search API URL")
	flag.StringVar(&apiKey, "api-key", "", "Wallhaven API Key")

	flag.DurationVar(&t, "timeout", 32*time.Second, "Timeout for http client in seconds")
	flag.Parse()

}

func printDetails(whPhoto photo) {
	if quiet {
		return
	}
	if pathOnly {
		cetus.PrintPath(whPhoto.Path)
		return
	}
	fmt.Printf("Id: %s\n", whPhoto.Id)
	fmt.Printf("URL: %s\n", whPhoto.Url)
	fmt.Printf("Short URL: %s\n", whPhoto.ShortUrl)
	fmt.Printf("Source: %s\n", whPhoto.Source)
	fmt.Printf("Date: %s\n\n", whPhoto.CreatedAt)
	fmt.Printf("Resolution: %s\n", whPhoto.Resolution)
	fmt.Printf("Ratio: %s\n", whPhoto.Ratio)
	fmt.Printf("Views: %d\n", whPhoto.Views)
	fmt.Printf("Favorites: %d\n", whPhoto.Favorites)
	fmt.Printf("File Size: %d KiB\n", whPhoto.FileSize/1024)
	fmt.Printf("Category: %s\n", whPhoto.Category)
}

func whBody() (string, error) {
	reqInfo := make(map[string]string)
	reqInfo["api"] = api
	if random {
		reqInfo["random"] = "true"
	}

	body, err := wallhaven.GetWhJson(reqInfo, t)
	return body, err
}