package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	deltalake "github.com/tidbcloud/metering/delta-rs-golang"
)

func main() {
	fmt.Println("=== Delta Lake Table Exists Example ===")
	fmt.Println()

	// Create a temporary directory for the demo
	tempDir, err := os.MkdirTemp("/tmp", "delta_table_exists_example")
	if err != nil {
		log.Fatalf("Failed to create temp directory: %v", err)
	}
	defer os.RemoveAll(tempDir)

	tablePath := filepath.Join(tempDir, "my_table")
	fmt.Printf("Table path: %s\n", tablePath)
	fmt.Println()

	// 1. Check non-existent table
	fmt.Println("1. Checking non-existent table:")
	exists, err := deltalake.TableExists(tablePath, nil)
	if err != nil {
		log.Fatalf("Error checking table existence: %v", err)
	}
	fmt.Printf("   Table exists: %v (expected: false)\n", exists)
	fmt.Println()

	// 2. Create a Delta table
	fmt.Println("2. Creating Delta Lake table:")
	columns := []deltalake.ColumnDefinition{
		{Name: "id", Type: "integer", Nullable: false},
		{Name: "name", Type: "string", Nullable: true},
		{Name: "age", Type: "integer", Nullable: true},
		{Name: "active", Type: "boolean", Nullable: true},
		{Name: "created_at", Type: "timestamp", Nullable: false},
	}

	options := deltalake.CreateTableOptions{
		TablePath: tablePath,
		SaveMode:  deltalake.WriteModeOverwrite,
		Columns:   columns,
	}

	table, err := deltalake.CreateDeltaLakeTable(options)
	if err != nil {
		log.Fatalf("Failed to create table: %v", err)
	}
	defer table.Close()
	fmt.Printf("   Table created successfully at: %s\n", tablePath)
	fmt.Println()

	// 3. Check existing table
	fmt.Println("3. Checking existing table:")
	exists, err = deltalake.TableExists(tablePath, nil)
	if err != nil {
		log.Fatalf("Error checking existing table: %v", err)
	}
	fmt.Printf("   Table exists: %v (expected: true)\n", exists)
	fmt.Println()

	// 4. Check with storage options
	fmt.Println("4. Checking table with storage options:")
	storageOptions := map[string]string{
		"AWS_REGION":                 "us-west-2",
		"AWS_S3_ALLOW_UNSAFE_RENAME": "true",
	}
	exists, err = deltalake.TableExists(tablePath, storageOptions)
	if err != nil {
		log.Fatalf("Error checking table with storage options: %v", err)
	}
	fmt.Printf("   Table exists with storage options: %v (expected: true)\n", exists)
	fmt.Println()

	// 5. Error case demonstration
	fmt.Println("5. Error case demonstration:")
	fmt.Println("   Checking empty path:")
	exists, err = deltalake.TableExists("", nil)
	if err != nil {
		fmt.Printf("   Expected error: %v\n", err)
	} else {
		fmt.Printf("   Unexpected success: %v\n", exists)
	}
	fmt.Println()

	// 6. Check non-Delta directory
	fmt.Println("6. Checking non-Delta directory:")
	nonDeltaPath := filepath.Join(tempDir, "regular_directory")
	err = os.MkdirAll(nonDeltaPath, 0755)
	if err != nil {
		log.Fatalf("Failed to create regular directory: %v", err)
	}

	exists, err = deltalake.TableExists(nonDeltaPath, nil)
	if err != nil {
		log.Fatalf("Error checking non-Delta directory: %v", err)
	}
	fmt.Printf("   Regular directory exists as Delta table: %v (expected: false)\n", exists)
	fmt.Println()

	// 7. Integration with OpenDeltaLakeTable
	fmt.Println("7. Integration with OpenDeltaLakeTable:")

	// First verify table exists
	exists, err = deltalake.TableExists(tablePath, nil)
	if err != nil {
		log.Fatalf("Error checking table existence: %v", err)
	}
	fmt.Printf("   Table exists: %v\n", exists)

	if exists {
		// Try to open the table
		openedTable, err := deltalake.OpenDeltaLakeTable(tablePath, nil)
		if err != nil {
			log.Fatalf("Failed to open existing table: %v", err)
		}
		defer openedTable.Close()

		// Get table version
		version, err := openedTable.Version()
		if err != nil {
			log.Fatalf("Failed to get table version: %v", err)
		}
		fmt.Printf("   Successfully opened table, version: %d\n", version)
	}
	fmt.Println()

	fmt.Println("=== Example completed successfully ===")
}