vodular/main.go

package main

import (
	"context"
	_ "embed"
	"encoding/json"
	"fmt"
	"log"
	"math"
	"net/http"
	"os"
	"path"
	"strings"
	"sync"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/youtube/v3"

	"arimelody.space/vodular/config"
	"arimelody.space/vodular/scanner"
	vid "arimelody.space/vodular/video"
	yt "arimelody.space/vodular/youtube"
)

//go:embed res/help.txt
var helpText string

const SEGMENT_EXTENSION = "mkv"
const MAX_TITLE_LEN = 100
const MAX_DESCRIPTION_LEN = 5000

func showHelp() {
	fmt.Println(helpText)
	os.Exit(0)
}

func main() {
	// config
	userConfigDir, err := os.UserConfigDir()
	if err != nil {
		log.Fatalf("Could not determine user configuration directory: %v", err)
		os.Exit(1)
	}
	config.CONFIG_FILENAME = path.Join(userConfigDir, "vodular", "config.toml")
	cfg, err := config.ReadConfig(config.CONFIG_FILENAME)
	if err != nil {
		log.Fatalf("Failed to read config: %v", err)
		os.Exit(1)
	}
	if cfg == nil {
		err = os.MkdirAll(path.Dir(config.CONFIG_FILENAME), 0750)
		if err != nil {
			log.Fatalf("Failed to create config directory: %v", err)
			os.Exit(1)
		}
		err = config.GenerateConfig(config.CONFIG_FILENAME)
		if err != nil {
			log.Fatalf("Failed to generate config: %v", err)
			os.Exit(1)
		}
		log.Printf(
			"New config file created (%s). " +
			"Please edit this file before running again!",
			config.CONFIG_FILENAME,
		)
		os.Exit(0)
	}

	// arguments
	if len(os.Args) < 2 || os.Args[1] == "--help" || os.Args[1] == "-h" {
		showHelp()
	}

	var verbose bool = false
	var initDirectory bool = false
	var logout bool = false
	var deleteFullVod bool = false
	var forceUpload bool = false
	var directory string

	for i, arg := range os.Args {
		if i == 0 { continue }
		if strings.HasPrefix(arg, "-") {
			switch arg {

			case "-h":
				fallthrough
			case "--help":
				showHelp()

			case "-v":
				fallthrough
			case "--verbose":
				verbose = true

			case "--init":
				initDirectory = true

			case "--logout":
				logout = true

			case "-d":
				fallthrough
			case "--deleteAfter":
				deleteFullVod = true

			case "-f":
				fallthrough
			case "--force":
				forceUpload = true

			default:
				fmt.Fprintf(os.Stderr, "Unknown option `%s`\n", arg)
				os.Exit(1)

			}
		} else {
			directory = arg
		}
	}

	if !strings.HasPrefix(directory, "/") {
		if wd, err := os.Getwd(); err != nil {
			directory = path.Join(directory, wd)
		}
	}

	// logout (--logout)
	if logout {
		cfg.Token = nil
		err = config.WriteConfig(cfg, config.CONFIG_FILENAME)
		if err != nil {
			log.Fatalf("Failed to write config: %v", err)
			os.Exit(1)
		}
		log.Println("Logged out successfully.")
		os.Exit(0)
	}

	// initialising directory (--init)
	if initDirectory {
		err = initialiseDirectory(directory)
		if err != nil {
			log.Fatalf("Failed to initialise directory: %v", err)
			os.Exit(1)
		}
		log.Printf(
			"Directory successfully initialised. " +
			"Be sure to update %s before uploading!",
			scanner.METADATA_FILENAME,
		)
		os.Exit(0)
	}

	// good to have early on
	templates, err := yt.FetchTemplates(path.Join(userConfigDir, "vodular", "templates"))
	if err != nil {
		log.Fatalf("Failed to fetch templates: %v", err)
		os.Exit(1)
	}

	// read directory metadata
	metadata, err := scanner.ReadMetadata(directory)
	if err != nil {
		if os.IsNotExist(err) {
			log.Fatalf("Directory does not exist: %s", directory)
			os.Exit(1)
		}
		log.Fatalf("Failed to fetch VOD metadata: %v", err)
		os.Exit(1)
	}
	if metadata == nil {
		log.Fatal(
			"Directory contained no metadata. " +
			"Use `--init` to initialise this directory.",
		)
		os.Exit(1)
	}

	// skip uploading if already done
	if metadata.Uploaded == !forceUpload {
		log.Printf(
			"VOD has already been uploaded. " +
			"Use --force to override, or update the %s.",
			scanner.METADATA_FILENAME,
		)
		os.Exit(0)
	}

	// default footage directory
	if len(metadata.FootageDir) == 0 {
		metadata.FootageDir = directory
	} else if !strings.HasPrefix(metadata.FootageDir, "/") {
		metadata.FootageDir = path.Join(directory, metadata.FootageDir)
	}

	// scan for VOD segments
	vodFiles, err := scanner.ScanSegments(metadata.FootageDir, SEGMENT_EXTENSION)
	if err != nil {
		log.Fatalf("Failed to fetch VOD filenames: %v", err)
		os.Exit(1)
	}
	if len(vodFiles) == 0 {
		log.Fatalf(
			"Directory contained no VOD files (expecting .%s)",
			SEGMENT_EXTENSION,
		)
		os.Exit(1)
	}
	if verbose {
		enc := json.NewEncoder(os.Stdout)
		enc.SetIndent("", "\t")
		fmt.Printf("Directory metadata: ")
		enc.Encode(metadata)
		fmt.Printf("\nVOD files available: ")
		enc.Encode(vodFiles)
	}

	// build video template for upload
	video, err := yt.BuildVideo(metadata)
	if err != nil {
		log.Fatalf("Failed to build video template: %v", err)
		os.Exit(1)
	}
	title, err := yt.BuildTemplate(video, templates.Title)
	if err != nil {
		log.Fatalf("Failed to build video title: %v", err)
		os.Exit(1)
	}
	description, err := yt.BuildTemplate(video, templates.Description)
	if err != nil {
		log.Fatalf("Failed to build video description: %v", err)
		os.Exit(1)
	}
	if len(title) > 100 {
		log.Fatalf(
			"Video title length exceeds %d characters (%d). YouTube may reject this!",
			MAX_TITLE_LEN,
			len(video.Title),
		)
	}
	if len(description) > 5000 {
		log.Fatalf(
			"Video description length exceeds %d characters (%d). YouTube may reject this!",
			MAX_DESCRIPTION_LEN,
			len(description),
		)
	}
	if verbose {
		enc := json.NewEncoder(os.Stdout)
		fmt.Printf("\nVideo template: ")
		enc.Encode(video)

		fmt.Printf(
			"\n================================\n\n" +
			"< TITLE >\n%s\n\n" +
			"< DESCRIPTION >\n%s\n" +
			"\n================================\n",
			title, description,
		)
	}

	// concatenate VOD segments into full VOD
	fullVodExists := func () bool {
		// check if full VOD already exists with expected duration
		fullVodProbe, err := scanner.ProbeSegment(video.Filename)
		if err != nil { return false }
		video.SizeBytes = fullVodProbe.Format.Size
		var totalLength float64 = 0

		for _, filename := range vodFiles {
			probe, err := scanner.ProbeSegment(path.Join(metadata.FootageDir, filename))
			if err != nil { continue }
			totalLength += probe.Format.Duration
		}
		return math.Abs(fullVodProbe.Format.Duration - totalLength) < float64(0.1)
	}()
	if fullVodExists {
		log.Print("Full VOD appears to already exist- uploading this file...")
	} else {
		video.SizeBytes, err = vid.ConcatVideo(video, vodFiles, verbose)
		if err != nil {
			log.Fatalf("Failed to concatenate VOD segments: %v", err)
			os.Exit(1)
		}
	}

	// youtube oauth flow
	ctx := context.Background()
	oauth2Config := &oauth2.Config{
		ClientID: cfg.Google.ClientID,
		ClientSecret: cfg.Google.ClientSecret,
		Endpoint: google.Endpoint,
		Scopes: []string{ youtube.YoutubeScope },
		RedirectURL: cfg.RedirectUri,
	}
	var token *oauth2.Token
	if cfg.Token != nil {
		token = cfg.Token
	} else {
		token, err = generateOAuthToken(&ctx, oauth2Config, cfg)
		if err != nil {
			log.Fatalf("OAuth flow failed: %v", err)
			os.Exit(1)
		}
		cfg.Token = token
	}
	tokenSource := oauth2Config.TokenSource(ctx, token)
	if err != nil {
		log.Fatalf("Failed to create OAuth2 token source: %v", err)
		os.Exit(1)
	}

	err = config.WriteConfig(cfg, config.CONFIG_FILENAME)
	if err != nil {
		log.Fatalf("Failed to save OAuth token: %v", err)
	}

	// okay actually upload now!
	ytVideo, err := yt.UploadVideo(ctx, tokenSource, video, templates)
	if err != nil {
		log.Fatalf("Failed to upload video: %v", err)
		os.Exit(1)
	}
	if verbose {
		jsonString, err := json.MarshalIndent(ytVideo, "", "  ")
		if err != nil {
			log.Fatalf("Failed to marshal video data json: %v", err)
		}
		fmt.Println(string(jsonString))
	}
	log.Print("Video uploaded successfully!")

	// update metadata to reflect VOD is uploaded
	// TODO: rather than a boolean flag, link to actual video
	metadata.Uploaded = true
	err = scanner.WriteMetadata(directory, metadata)
	if err != nil {
		log.Fatalf("Failed to update metadata: %v", err)
	}

	// delete full VOD after upload, if requested
	if deleteFullVod {
		err = os.Remove(video.Filename)
		if err != nil {
			log.Fatalf("Failed to delete full VOD: %v", err)
		}
	}
}

func initialiseDirectory(directory string) error {
	dirInfo, err := os.Stat(directory)
	if err != nil {
		if os.IsNotExist(err) {
			return fmt.Errorf("no such directory: %s", directory)
		}
		return fmt.Errorf("failed to open directory: %v", err)
	}
	if !dirInfo.IsDir() {
		return fmt.Errorf("not a directory: %s", directory)
	}

	_, err = os.Stat(path.Join(directory, scanner.METADATA_FILENAME))
	if err == nil {
		return fmt.Errorf("directory already initialised: %s", directory)
	}

	err = scanner.WriteMetadata(directory, scanner.DefaultMetadata())

	return err
}

func generateOAuthToken(
	ctx *context.Context,
	oauth2Config *oauth2.Config,
	cfg *config.Config,
) (*oauth2.Token, error) {
	verifier := oauth2.GenerateVerifier()

	var token *oauth2.Token
	wg := sync.WaitGroup{}
	var server http.Server
	server.Addr = cfg.Host
	server.Handler = http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			if !r.URL.Query().Has("code") {
				http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
				return
			}

			code := r.URL.Query().Get("code")

			t, err := oauth2Config.Exchange(*ctx, code, oauth2.VerifierOption(verifier))
			if err != nil {
				log.Fatalf("Could not exchange OAuth2 code: %v", err)
				http.Error( w,
					fmt.Sprintf("Could not exchange OAuth2 code: %v", err),
					http.StatusBadRequest,
				)
				return
			}

			token = t
			http.Error(
				w,
				"Authentication successful! You may now close this tab.",
				http.StatusOK,
			)
			if f, ok := w.(http.Flusher); ok {
				f.Flush()
			}

			wg.Done()
			server.Close()
		},
	)

	url := oauth2Config.AuthCodeURL(
		"state",
		oauth2.AccessTypeOffline,
		oauth2.S256ChallengeOption(verifier),
	)
	fmt.Printf("\nSign in to YouTube: %s\n\n", url)

	wg.Add(1)
	if err := server.ListenAndServe(); err != http.ErrServerClosed {
		return nil, fmt.Errorf("http: %v", err)
	}
	wg.Wait()

	return token, nil
}