vodular/main.go

package main

import (
	"context"
	_ "embed"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path"
	"strings"

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

	"arimelody.space/live-vod-uploader/config"
	"arimelody.space/live-vod-uploader/scanner"
	vid "arimelody.space/live-vod-uploader/video"
	yt "arimelody.space/live-vod-uploader/youtube"
)

const segmentExtension = "mkv"

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

func showHelp() {
	execSplits := strings.Split(os.Args[0], "/")
	execName := execSplits[len(execSplits) - 1]
	fmt.Printf(helpText, execName)
}

func main() {
	if len(os.Args) < 2 || os.Args[1] == "--help" || os.Args[1] == "-h" {
		showHelp()
		os.Exit(0)
	}

	var verbose bool = false
	var initDirectory 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()
				os.Exit(0)

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

			case "--init":
				initDirectory = 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
		}
	}

	// config
	cfg, err := config.ReadConfig(config.CONFIG_FILENAME)
	if err != nil {
		log.Fatalf("Failed to read config: %v", err)
		os.Exit(1)
	}
	if cfg == nil {
		log.Printf(
			"New config file created (%s). " +
			"Please edit this file before running again!",
			config.CONFIG_FILENAME,
		)
		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")
	}

	// read directory metadata
	metadata, err := scanner.ReadMetadata(directory)
	if err != nil {
		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)
	}

	// scan for VOD segments
	vodFiles, err := scanner.ScanSegments(metadata.FootageDir, segmentExtension)
	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)",
			segmentExtension,
		)
		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)
	}
	if verbose {
		enc := json.NewEncoder(os.Stdout)
		fmt.Printf("\nVideo template: ")
		enc.Encode(video)

		title, err := yt.BuildTitle(video)
		if err != nil {
			log.Fatalf("Failed to build video title: %v", err)
			os.Exit(1)
		}
		description, err := yt.BuildDescription(video)
		if err != nil {
			log.Fatalf("Failed to build video description: %v", err)
			os.Exit(1)
		}
		fmt.Printf(
			"\nTITLE: %s\nDESCRIPTION: %s",
			title, description,
		)
	}

	// concatenate VOD segments into full VOD
	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()
	token, err := completeOAuth(&ctx, cfg)
	if err != nil {
		log.Fatalf("OAuth flow failed: %v", err)
		os.Exit(1)
	}

	// okay actually upload now!
	ytVideo, err := yt.UploadVideo(ctx, token, video)
	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
	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(path.Join(directory, scanner.METADATA_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 err == os.ErrNotExist {
			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: %v", err)
	}

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

	return err
}

func completeOAuth(ctx *context.Context, cfg *config.Config) (*oauth2.Token, error) {
	oauth2Config := &oauth2.Config{
		ClientID: cfg.Google.ClientID,
		ClientSecret: cfg.Google.ClientSecret,
		Endpoint: google.Endpoint,
		Scopes: []string{ youtube.YoutubeScope },
		RedirectURL: "http://localhost:8090",
	}
	verifier := oauth2.GenerateVerifier()

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

	// TODO: tidy up oauth flow with localhost webserver
	var code string
	fmt.Print("Enter OAuth2 code: ")
	if _, err := fmt.Scan(&code); err != nil {
		return nil, fmt.Errorf("failed to read code: %v", err)
	}

	token, err := oauth2Config.Exchange(*ctx, code, oauth2.VerifierOption(verifier))
	if err != nil {
		log.Fatalf("Could not exchange OAuth2 code: %v", err)
		os.Exit(1)
	}

	// TODO: save this token; look into token refresh
	log.Printf("Token expires on %s\n", token.Expiry.Format("02 Jan 2006"))

	return token, nil
}