package main

import (
	"database/sql"
     "fmt"
   "log"
	"io"
	"io/ioutil"
	"os"
	"path"

	_ "modernc.org/sqlite"
)

const (
	jellyDB   = "jellyfin.db"
	libraryDB = "library.db"
)

func main() {
	data := os.Args[1]
	fromU := os.Args[2]
	toU := os.Args[3]
   _ = toU

	workd, err := ioutil.TempDir(os.TempDir(), "jellyfin-user-clone.*")
	if err != nil {
		panic(err)
	}

	if err := cp(path.Join(data, jellyDB), path.Join(workd, jellyDB)); err != nil {
		panic(err)
	} else if err := cp(path.Join(data, libraryDB), path.Join(workd, libraryDB)); err != nil {
		panic(err)
	}

	jellyfinDB, err := sql.Open("sqlite", path.Join(workd, jellyDB))
	if err != nil {
		panic(err)
	}
	defer jellyfinDB.Close()

   fromUUID, err := SelectOne[string](jellyfinDB, `SELECT Id FROM Users WHERE Username = $1`, fromU)
   if err != nil {
      panic(err)
   }

   fromID, err := SelectOne[int](jellyfinDB, `SELECT InternalId FROM Users WHERE Id = $1`, fromUUID)
   if err != nil {
      panic(err)
   }

   log.Println(fromU, fromUUID, fromID)
}

func cp(from, to string) error {
	fromF, err := os.Open(from)
	if err != nil {
		return err
	}
	defer fromF.Close()

	toF, err := os.Create(to)
	if err != nil {
		return err
	}
	defer toF.Close()

	_, err = io.Copy(toF, fromF)
	return err
}

func SelectOne[T any](db *sql.DB, q string, args ...any) (T, error) {
   var some T

   results, err := Select[T](db, q, args...)
   if err != nil {
      return some, err
   }

   if len(results) != 1 {
      return some, fmt.Errorf("expected 1 result but got %d (%+v)", len(results), results)
   }

   return results[0], nil
}

func Select[T any](db *sql.DB, q string, args ...any) ([]T, error) {
   rows, err := db.Query(q, args...)
   if err != nil {
      return nil, err
   }
   defer rows.Close()

   results := []T{}
   for rows.Next() {
      var some T
      if err := rows.Scan(&some); err != nil {
         return nil, err
      }
      results = append(results, some)
   }

   return results, rows.Err()
}