package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"math/rand"
	"net/http"
	"os"
	"strings"
	"text/template"

	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
	"gopkg.in/yaml.v3"
)

func GetPicsArray() []string {
	files, err := os.ReadDir("images")
	if err != nil {
		panic(err)
	}
	if len(files) == 0 {
		return []string{"no images"}
	}
	var filesNames = make([]string, len(files))
	for i, file := range files {
		filesNames[i] = string("images/" + file.Name())
	}
	return filesNames
}

func (conf *ConfHandler) GetRandImgS3() string {
	picsArray := GetObjectsFilenames(conf.ConfigHandler, conf.minioClient)
	return picsArray[rand.Intn(len(picsArray))]
}

func (conf *ConfHandler) ReturnObjectName(w http.ResponseWriter, req *http.Request) {
	var picFilename io.Reader = strings.NewReader(conf.GetRandImgS3())
	log.Println("Картинка отдана")
	io.Copy(w, picFilename)
}

func (conf *ConfHandler) ReturnHTMLS3(w http.ResponseWriter, req *http.Request) {
	htmlOpen, err := template.ParseFiles("dist/index.html")
	if err != nil {
		log.Println(err.Error())
		return
	}
	image := conf.GetRandImgS3()
	fmt.Println(image)
	htmlOpen.Execute(w, image)
}

func GetRandImg() string {
	picsArray := GetPicsArray()
	return picsArray[rand.Intn(len(picsArray))]
}

func ReturnPicFilename(w http.ResponseWriter, req *http.Request) {
	var picFilename io.Reader = strings.NewReader(GetRandImg())
	log.Println("Картинка отдана")
	io.Copy(w, picFilename)
}

func ReturnHTML(w http.ResponseWriter, req *http.Request) {
	htmlOpen, err := template.ParseFiles("dist/index.html")
	if err != nil {
		log.Println(err.Error())
		return
	}
	image := GetRandImg()
	fmt.Println(image)
	htmlOpen.Execute(w, image)
}

type Config struct {
	UseS3     bool   `yaml:"use_s3"`
	Address   string `yaml:"address"`
	Bucket    string `yaml:"bucket"`
	AccessKey string `yaml:"access_key"`
	SecretKey string `yaml:"secret_key"`
}

type ConfHandler struct {
	ConfigHandler Config
	minioClient   minio.Client
}

func InitConf(filename string) Config {
	var conf Config
	configFile, _ := os.ReadFile(filename)
	err := yaml.Unmarshal(configFile, &conf)
	if err != nil {
		log.Fatal(err)
	}

	return conf
}

func GetObjectsFilenames(conf Config, minioClient minio.Client) []string {

	ctx, cancel := context.WithCancel(context.Background())

	defer cancel()

	objectCh := minioClient.ListObjects(ctx, conf.Bucket, minio.ListObjectsOptions{Recursive: false})

	fmt.Println(objectCh)
	objectsKeyArr := []string{}

	for object := range objectCh {
		if object.Err != nil {
			fmt.Println(object.Err)
		}
		objectsKeyArr = append(objectsKeyArr, "https://"+conf.Address+"/"+conf.Bucket+"/"+object.Key)
	}
	return objectsKeyArr
}

func main() {
	log.Println("Server Start")
	conf := InitConf("config.yaml")
	imagesDir := http.FileServer(http.Dir("images"))
	staticDir := http.FileServer(http.Dir("dist/assets"))
	http.Handle("/images/", http.StripPrefix("/images/", imagesDir))
	http.Handle("/assets/", http.StripPrefix("/assets/", staticDir))

	if !conf.UseS3 {
		http.HandleFunc("/rand", ReturnPicFilename)
		http.HandleFunc("/", ReturnHTML)
	} else {
		var confHandler ConfHandler
		minioClient, err := minio.New(conf.Address, &minio.Options{
			Creds:  credentials.NewStaticV4(conf.AccessKey, conf.SecretKey, ""),
			Secure: true,
		})

		if err != nil {
			log.Fatalln(err)
		}
		confHandler.minioClient = *minioClient
		confHandler.ConfigHandler = conf
		http.HandleFunc("/rand", confHandler.ReturnObjectName)
		http.HandleFunc("/", confHandler.ReturnHTMLS3)
	}

	http.ListenAndServe(":3666", nil)
}