// App.tsx
import React from 'react';
import { GodotProvider } from 'react-native-godot';
import MyGameScreen from './MyGameScreen';

export default function App() {
  return (
    <GodotProvider>
      <MyGameScreen />
    </GodotProvider>
  );
}

// MyGameScreen.tsx
import React, { useEffect, useState } from 'react';
import { GodotView, useGodot, useGodotRef } from 'react-native-godot';

const MyGameScreen = () => {
  const godotRef = useGodotRef();
  const { Vector3, Vector2 } = useGodot();
  const [isGodotReady, setIsGodotReady] = useState(false);

  useEffect(() => {
    // Start Godot rendering (call once in your app)
    GodotView.startDrawing();

    return () => {
      // Stop Godot rendering when component unmounts
      GodotView.stopDrawing();
    };
  }, []);

  useEffect(() => {
    if (!isGodotReady || !godotRef.current) {
      return;
    }

    // Use Godot variants
    const position = Vector3(1, 2, 3);
    console.log('Position Y:', position.y);

    // Get nodes from your scene
    const playerNode = godotRef.current.getRoot()?.getNode('Player');
    playerNode?.call('jump', 10);

    // Send data to Godot
    godotRef.current.emitMessage({
      type: 'player_spawn',
      position: position,
      health: 100
    });

  }, [isGodotReady]);

  return (
    <GodotView
      ref={godotRef}
      style={{ flex: 1 }}
      source={require('./assets/game.pck')}
      scene="res://main.tscn"
      onReady={() => setIsGodotReady(true)}
      onMessage={(instance, message) => {
        console.log('Message from Godot:', message);
      }}
    />
  );
};

export default MyGameScreen;

const MyGame = () => {
  const godotRef = useGodotRef();

  useEffect(() => {
    // Start rendering when app launches
    GodotView.startDrawing();
    return () => GodotView.stopDrawing();
  }, []);

  return (
    <GodotView
      ref={godotRef}
      source={require('./game.pck')}
      scene="res://main.tscn"
      onReady={(instance) => {
        console.log('Godot ready!');
        instance.emitMessage({ type: 'game_start' });
      }}
      onMessage={(instance, message) => {
        console.log('From Godot:', message);
      }}
    />
  );
};

const MultiSceneApp = () => {
  const gameRef = useGodotRef();
  const uiRef = useGodotRef();
  const minimapRef = useGodotRef();

  useEffect(() => {
    // Start rendering once for all GodotView instances
    GodotView.startDrawing();
    return () => GodotView.stopDrawing();
  }, []);

  return (
    <View style={{ flex: 1 }}>
      {/* Main game view */}
      <GodotView
        ref={gameRef}
        source={require('./game.pck')}
        scene="res://game_world.tscn"
        style={{ flex: 1 }}
      />
      
      {/* UI overlay */}
      <GodotView
        ref={uiRef}
        source={require('./ui.pck')}
        scene="res://hud.tscn"
        style={{ 
          position: 'absolute',
          top: 0,
          left: 0,
          width: '100%',
          height: 100 
        }}
      />
      
      {/* Minimap */}
      <GodotView
        ref={minimapRef}
        source={require('./game.pck')}
        scene="res://minimap.tscn"
        style={{ 
          position: 'absolute',
          top: 20,
          right: 20,
          width: 150,
          height: 150 
        }}
      />
    </View>
  );
};

// Pause the minimap when not needed
minimapRef.current?.pause();

// Resume it later
minimapRef.current?.resume();

// Pause game but keep UI active
gameRef.current?.pause();
// UI continues running for menus, etc.

const { Vector3, Color, Transform3D } = useGodot();

// Create variants
const position = Vector3(1, 2, 3);
const color = Color(1, 0, 0, 1); // Red
const transform = Transform3D();

// Use methods and properties
console.log('Distance:', position.length());
console.log('Normalized:', position.normalized());
console.log('Red component:', color.r);

const { Script, Node } = useGodot();

// Create and compile a script
const script = Script();
const success = script.setSourceCode(`
extends Node

@onready var health = 100

func _ready():
    print("Dynamic script loaded!")

func take_damage(amount: int) -> int:
    health -= amount
    return health

func heal(amount: int):
    health += amount
    print("Healed for ", amount, " HP")
`);

if (success) {
  // Create node and attach script
  const dynamicNode = Node();
  dynamicNode.setScript(script);
  dynamicNode.setName("DynamicPlayer");
  
  // Add to scene
  godotRef.current?.getRoot()?.addChild(dynamicNode);
  
  // Call script methods
  const remainingHealth = dynamicNode.call("take_damage", 25);
  console.log('Health remaining:', remainingHealth);
  
  // Alternative syntax with TypeScript casting
  (dynamicNode as any).heal(10);
}

useEffect(() => {
  if (!isGodotReady || !godotRef.current) return;

  // Get the root node
  const root = godotRef.current.getRoot();
  
  // Navigate the scene tree
  const player = root?.getNode('Player');
  const ui = root?.getNode('UI/HealthBar');
  
  // Access node hierarchy
  const parent = player?.getParent();
  const children = player?.getChildren();
  const siblingCount = parent?.getChildCount();
  
  // Call methods defined in the node's GDScript
  player?.call('set_health', 100);
  ui?.call('update_display', 100, 100);
  
  // Alternative direct method calls
  (player as any)?.jump(15);
  (ui as any)?.show_damage_effect();
  
}, [isGodotReady]);

// Send structured data to Godot
godotRef.current?.emitMessage({
  type: 'player_action',
  action: 'attack',
  target: 'enemy_1',
  position: Vector3(10, 0, 5),
  damage: 50
});

<GodotView
  onMessage={(instance, message) => {
    console.log('Received from Godot:', message);
    
    // Handle different message types
    switch (message.type) {
      case 'game_over':
        showGameOverScreen(message.score);
        break;
      case 'level_complete':
        advanceToNextLevel();
        break;
      case 'item_collected':
        updateInventory(message.item);
        break;
    }
  }}
/>