// Flutter: sending scene commands to Unity

// Load scene (additive)
bridge.send(UnityMessage.command('LoadScene', {
  'sceneName': 'GameShowroom',
  'mode': 'additive',  // or 'single'
}));

// Unload scene
bridge.send(UnityMessage.command('UnloadScene', {
  'sceneName': 'ItemCollection',
}));

// Swap scene
bridge.send(UnityMessage.command('SwapScene', {
  'oldScene': 'ItemCollection',
  'newScene': 'GameShowroom',
}));

// Flutter: listening for scene events

// Track scene loading (progress bar in Flutter)
bridge.messageStream
  .where((msg) => msg.type == 'scene_loading_progress')
  .listen((msg) {
    final progress = msg.data?['progress'] as double? ?? 0;
    final sceneName = msg.data?['sceneName'] as String? ?? '';
    setState(() {
      _loadingProgress = progress;
      _loadingScene = sceneName;
    });
  });

// Scene loaded
bridge.sceneStream.listen((SceneInfo info) {
  debugPrint('Scene ${info.name} loaded');
  debugPrint('  buildIndex: ${info.buildIndex}');
  debugPrint('  isLoaded: ${info.isLoaded}');
  debugPrint('  isValid: ${info.isValid}');

  // Update Flutter application state
  context.read<SceneCubit>().onSceneLoaded(info);
});

// Scene unloaded
bridge.messageStream
  .where((msg) => msg.type == 'scene_unloaded')
  .listen((msg) {
    context.read<SceneCubit>().onSceneUnloaded(msg.data?['sceneName']);
  });

// ═══ ASYNCHRONOUS — basic (recommended on mobile) ═══
AsyncOperation op = SceneManager.LoadSceneAsync("GameShowroom", LoadSceneMode.Additive);
// Scene loads in the background — Unity allocates time per frame.
// progress: 0.0 → 0.9 = loading, 0.9 = ready for activation.
op.completed += (asyncOp) => {
    Debug.Log("Scene GameShowroom loaded!");
};

// ═══ UNLOADING a scene (CRITICAL on mobile — memory!) ═══
IEnumerator UnloadScene(string sceneName)
{
    AsyncOperation op = SceneManager.UnloadSceneAsync(sceneName);
    yield return op;

    // After unloading the scene, assets may still remain in memory!
    yield return Resources.UnloadUnusedAssets();
    System.GC.Collect();
}

// ═══ From Build Settings ═══
SceneManager.LoadSceneAsync("GameShowroom", LoadSceneMode.Additive);
// Scene MUST be in File > Build Settings > Scenes In Build

// ═══ From AssetBundle ═══
// Step 1: load the bundle containing the scene
AssetBundle sceneBundle = AssetBundle.LoadFromFile(
    Path.Combine(Application.persistentDataPath, "scenes/gameshowroom")
);
// Step 2: load the scene from the bundle (by name, not path)
SceneManager.LoadSceneAsync("GameShowroom", LoadSceneMode.Additive);
// Step 3: unload the bundle after loading the scene
sceneBundle.Unload(false);

// ═══ From Addressables ═══
var sceneHandle = Addressables.LoadSceneAsync(
    "Scenes/GameShowroom",
    LoadSceneMode.Additive,
    activateOnLoad: true
);
// sceneHandle.Result = SceneInstance (for later unload)
SceneInstance sceneInstance = await sceneHandle.Task;

// Unloading:
Addressables.UnloadSceneAsync(sceneHandle);

// ═══ METHOD 1: Addressables — RECOMMENDED ═══

// A. Load + Instantiate separately (when you need a reference to the prefab)
var loadHandle = Addressables.LoadAssetAsync<GameObject>("Models/Model_001");
GameObject prefab = await loadHandle.Task;
GameObject instance1 = Instantiate(prefab, pos1, Quaternion.identity, parent);
// Release prefab when you no longer need more instances (existing instances survive)
Addressables.Release(loadHandle);

// B. InstantiateAsync — load + instantiate in one step
var instHandle = Addressables.InstantiateAsync(
    "Models/Model_001",
    position: Vector3.zero,
    rotation: Quaternion.identity,
    parent: modelContainer.transform
);
GameObject model = await instHandle.Task;
// ReleaseInstance destroys the object AND releases the asset
Addressables.ReleaseInstance(model);

// ═══ METHOD 2: AssetBundle — lower level, full control ═══
string bundlePath = Path.Combine(Application.persistentDataPath, "bundles/models");
AssetBundle bundle = await AssetBundle.LoadFromFileAsync(bundlePath);
GameObject prefab = bundle.LoadAsset<GameObject>("Model_001");
GameObject instance = Instantiate(prefab, Vector3.zero, Quaternion.identity);
bundle.Unload(false); // false = do not destroy loaded assets in memory

// ═══ METHOD 3: Resources — NOT RECOMMENDED (but worth knowing) ═══
// Files MUST be in the Assets/Resources/ folder.
// All Resources are packed into the build — they increase APK size.
GameObject prefab = Resources.Load<GameObject>("Models/Model_001");
Instantiate(prefab);
// Why not: everything goes into the build, no lazy loading, no remote, no cache.

// ═══ METHOD 4: glTF/GLB runtime — models from external sources ═══
var gltf = new GltfImport();
await gltf.Load("https://api.example.com/models/model.glb");
gltf.InstantiateMainScene(modelContainer.transform);

// Flutter: full API for managing models

class ModelController {
  final UnityBridge _bridge;

  ModelController(this._bridge);

  // Load model from Addressables
  void loadModel(String modelId) {
    _bridge.send(UnityMessage.to('ModelManager', 'LoadModel', {
      'modelId': modelId,
      'source': 'addressables',
    }));
  }

  // Load model from URL (glTF)
  void loadModelFromUrl(String modelId, String glbUrl) {
    _bridge.send(UnityMessage.to('ModelManager', 'LoadModel', {
      'modelId': modelId,
      'source': 'gltf',
      'url': glbUrl,
    }));
  }

  // Preload (download to cache without displaying)
  void preloadModel(String modelId) {
    _bridge.send(UnityMessage.to('ModelManager', 'PreloadModel', {
      'modelId': modelId,
    }));
  }

  // Swap model for another (smooth swap)
  void swapModel(String newModelId) {
    _bridge.send(UnityMessage.to('ModelManager', 'SwapModel', {
      'modelId': newModelId,
      'source': 'addressables',
    }));
  }

  // Remove current model
  void unloadModel() {
    _bridge.send(UnityMessage.command('UnloadModel', {}));
  }

  // Set position/rotation/scale
  void setTransform({
    double x = 0, double y = 0, double z = 0,
    double rx = 0, double ry = 0, double rz = 0,
    double sx = 1, double sy = 1, double sz = 1,
  }) {
    _bridge.send(UnityMessage.to('ModelManager', 'SetModelTransform', {
      'x': x, 'y': y, 'z': z,
      'rx': rx, 'ry': ry, 'rz': rz,
      'sx': sx, 'sy': sy, 'sz': sz,
    }));
  }

  // Set animation
  void setAnimation(String name, {double speed = 1.0}) {
    _bridge.send(UnityMessage.to('ModelManager', 'SetModelAnimation', {
      'animationName': name,
      'speed': speed,
    }));
  }

  // Change material
  void setMaterial(String materialAddress) {
    _bridge.send(UnityMessage.to('ModelManager', 'SetModelMaterial', {
      'materialAddress': materialAddress,
    }));
  }

  // Event streams
  Stream<Map<String, dynamic>> get onModelLoaded =>
      _bridge.messageStream
          .where((msg) => msg.type == 'model_loaded')
          .map((msg) => msg.data ?? {});

  Stream<Map<String, dynamic>> get onModelLoading =>
      _bridge.messageStream
          .where((msg) => msg.type == 'model_loading')
          .map((msg) => msg.data ?? {});

  Stream<Map<String, dynamic>> get onModelError =>
      _bridge.messageStream
          .where((msg) => msg.type == 'model_error')
          .map((msg) => msg.data ?? {});
}

// Recommended build: LZ4 (ChunkBased) compression, one build per platform.
// A bundle built for Android does NOT work on iOS — build separately.
BuildPipeline.BuildAssetBundles(
    outputPath,
    BuildAssetBundleOptions.ChunkBasedCompression, // LZ4
    BuildTarget.Android                            // OR BuildTarget.iOS
);

// Unload(false): release ONLY the bundle from memory.
// Loaded assets (prefabs, textures) REMAIN in memory.
bundle.Unload(false);

// Unload(true): release bundle + ALL loaded assets.
// Instances in the scene lose materials/textures (magenta). Use with care.
bundle.Unload(true);

// Cleanup orphaned assets (after Unload(false) + Destroy instances)
yield return Resources.UnloadUnusedAssets();
System.GC.Collect();

// A. Load prefab by address
var handle = Addressables.LoadAssetAsync<GameObject>("Models/Model_001");
GameObject prefab = await handle.Task;
GameObject instance = Instantiate(prefab);
// IMPORTANT: handle must be Release()'d when you no longer need more instances

// B. Load + Instantiate in one step
var instance = await Addressables.InstantiateAsync("Models/Model_001").Task;
// Cleanup: Addressables.ReleaseInstance(instance) → destroys AND releases

// C. Load a scene
var sceneHandle = Addressables.LoadSceneAsync(
    "Scenes/GameShowroom",
    LoadSceneMode.Additive,
    activateOnLoad: true
);
SceneInstance scene = await sceneHandle.Task;

// E. Load by label (all models with label "rare")
var listHandle = Addressables.LoadAssetsAsync<GameObject>(
    "rare",
    (GameObject prefab) => Debug.Log(prefab.name)
);
IList<GameObject> rareModels = await listHandle.Task;

1. Artist creates a new model in Unity Editor
2. Mark prefab as Addressable: "Models/NewModel_042"
3. Add to group "RemoteModels_Common", label "common"

4. Build content update (NOT a new app build!):
   Addressables > Build > Update Previous Build
   → Point to addressables_content_state.bin from the last build
   → Generates ONLY changed bundles + new catalog

5. Upload to CDN/CCD:
   ├── New catalog JSON + hash
   └── Only changed bundles (new model)

6. Users:
   ├── Open app → CatalogUpdater checks hash
   ├── New hash → download new catalog (a few KB)
   ├── "Models/NewModel_042" is now available
   └── When user wants to see it → download bundle (on demand)

No submission to App Store / Google Play!

// Flutter: load an external .glb (e.g. an NFT model) by URL.
// Uses the same ModelController — source 'gltf' routes to glTFast in Unity.
modelController.loadModelFromUrl('nft_042', 'https://api.example.com/models/model.glb');

// Track parsing/download + result
modelController.onModelLoading.listen((data) => setState(() => _loading = true));
modelController.onModelLoaded.listen((data) => setState(() => _loading = false));
modelController.onModelError.listen((data) => showError(data['error'] as String?));

// Package Manager → Add by name: com.unity.cloud.gltfast
using GLTFast;

var gltf = new GltfImport();
bool success = await gltf.Load("https://cdn.example.com/models/model_001.glb");

if (success) {
    // Instantiate MAIN scene from the glTF file
    var instantiator = new GameObjectInstantiator(gltf, parentTransform);
    await gltf.InstantiateMainSceneAsync(instantiator);

    // OR simpler version:
    gltf.InstantiateMainScene(parentTransform);
}

// Cleanup — free native resources (textures, meshes)
gltf.Dispose();

class ARScreen extends StatefulWidget {
  final UnityBridge bridge;
  final String modelId;

  const ARScreen({required this.bridge, required this.modelId});

  @override
  State<ARScreen> createState() => _ARScreenState();
}

class _ARScreenState extends State<ARScreen> {
  bool _planeDetected = false;
  bool _modelPlaced = false;
  double _modelScale = 1.0;

  @override
  void initState() {
    super.initState();
    widget.bridge.send(UnityMessage.command('EnableAR', {'modelId': widget.modelId}));
    widget.bridge.messageStream.listen(_onARMessage);
  }

  void _onARMessage(UnityMessage msg) {
    switch (msg.type) {
      case 'ar_plane_detected':
        setState(() => _planeDetected = true);
        break;
      case 'ar_model_placed':
        setState(() => _modelPlaced = true);
        break;
      case 'ar_screenshot_taken':
        final path = msg.data?['path'] as String? ?? '';
        _showScreenshotPreview(path);
        break;
    }
  }

  @override
  Widget build(BuildContext context) {
    return Stack(
      children: [
        UnityView(bridge: widget.bridge),
        SafeArea(
          child: Column(
            children: [
              Row(
                children: [
                  IconButton(
                    icon: const Icon(Icons.arrow_back, color: Colors.white),
                    onPressed: () {
                      widget.bridge.send(UnityMessage.command('DisableAR', {}));
                      Navigator.pop(context);
                    },
                  ),
                  const Spacer(),
                  if (_modelPlaced)
                    IconButton(
                      icon: const Icon(Icons.camera_alt, color: Colors.white),
                      onPressed: () {
                        widget.bridge.send(UnityMessage.command('TakeScreenshot', {}));
                      },
                    ),
                ],
              ),
              const Spacer(),
              if (!_planeDetected)
                _buildInstruction('Point camera at a flat surface'),
              if (_planeDetected && !_modelPlaced)
                _buildInstruction('Tap the surface to place the model'),
              if (_modelPlaced)
                Slider(
                  value: _modelScale,
                  min: 0.2,
                  max: 3.0,
                  onChanged: (value) {
                    setState(() => _modelScale = value);
                    widget.bridge.send(
                      UnityMessage.to('ARModelManager', 'ScaleModel', {'scale': value}),
                    );
                  },
                ),
            ],
          ),
        ),
      ],
    );
  }

  @override
  void dispose() {
    widget.bridge.send(UnityMessage.command('DisableAR', {}));
    super.dispose();
  }
}

/// Manages the AR session and communication with Flutter.
/// Mount on a GameObject with ARSession, XROrigin.
public class ARModelManager : FlutterMonoBehaviour
{
    [SerializeField] private ARRaycastManager raycastManager;
    [SerializeField] private ARPlaneManager planeManager;

    private GameObject _currentModel;
    private readonly List<ARRaycastHit> _raycastHits = new();

    // ─── Enable AR Session ───
    private async Task EnableAR(string modelId)
    {
        arSession.enabled = true;
        planeManager.enabled = true;
        planeManager.planesChanged += OnPlanesChanged;

        _currentModel = await Addressables.InstantiateAsync($"Models/{modelId}").Task;
        _currentModel.SetActive(false); // Hide until user taps

        SendToFlutter("ar_enabled", JsonUtility.ToJson(new {
            modelId = modelId,
            message = "Point camera at a surface"
        }));
    }

    // ─── Place Model at Screen Point (tap) ───
    private void PlaceModelAtScreenPoint(Vector2 screenPoint)
    {
        if (raycastManager.Raycast(screenPoint, _raycastHits, TrackableType.PlaneWithinPolygon))
        {
            Pose hitPose = _raycastHits[0].pose;
            _currentModel.transform.position = hitPose.position;
            _currentModel.transform.rotation = hitPose.rotation;
            _currentModel.SetActive(true);

            SendToFlutter("ar_model_placed", JsonUtility.ToJson(new {
                message = "Model placed! Use gestures to move/rotate."
            }));
        }
    }
}

class ModelViewerScreen extends StatefulWidget {
  final String modelId;
  final String? modelSource; // 'addressables' or 'gltf'
  final String? glbUrl;      // if source == 'gltf'

  const ModelViewerScreen({
    required this.modelId,
    this.modelSource = 'addressables',
    this.glbUrl,
  });

  @override
  State<ModelViewerScreen> createState() => _ModelViewerScreenState();
}

class _ModelViewerScreenState extends State<ModelViewerScreen> {
  late final UnityBridge _bridge;
  late final ModelController _modelController;

  bool _isReady = false;
  bool _isModelLoaded = false;
  bool _isDownloading = false;
  double _downloadProgress = 0;
  String? _errorMessage;

  @override
  void initState() {
    super.initState();
    _bridge = UnityBridgeImpl();
    _modelController = ModelController(_bridge);
    _initializeUnity();
  }

  Future<void> _initializeUnity() async {
    // 1. Initialize bridge
    await _bridge.initialize();

    // 2. Wait for Unity readiness (catalog update + remote config done)
    _bridge.eventStream
      .where((e) => e.type == UnityEventType.loaded)
      .first
      .then((_) {
        setState(() => _isReady = true);
        _loadModel();
      });

    // 3. Listen for events
    _bridge.messageStream.listen(_onMessage);
  }

  void _onMessage(UnityMessage msg) {
    switch (msg.type) {
      case 'model_loading':
        setState(() {
          _isModelLoaded = false;
          _errorMessage = null;
        });
        break;

      case 'model_download_required':
        setState(() {
          _isDownloading = true;
          _downloadProgress = 0;
        });
        break;

      case 'bundle_download_progress':
      case 'gltf_download_progress':
        setState(() {
          _downloadProgress = (msg.data?['progress'] as num?)?.toDouble() ?? 0;
        });
        break;

      case 'model_loaded':
      case 'gltf_loaded':
        setState(() {
          _isModelLoaded = true;
          _isDownloading = false;
        });
        break;

      case 'model_error':
      case 'gltf_error':
        setState(() {
          _errorMessage = msg.data?['error'] as String? ?? 'Unknown error';
          _isDownloading = false;
        });
        break;

      case 'remote_config_updated':
        // Config updated — Unity applied settings itself
        break;

      case 'catalog_updated':
        // New content available — optionally show "NEW" badge
        break;
    }
  }

  void _loadModel() {
    if (widget.modelSource == 'gltf' && widget.glbUrl != null) {
      _modelController.loadModelFromUrl(widget.modelId, widget.glbUrl!);
    } else {
      _modelController.loadModel(widget.modelId);
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Stack(
        children: [
          // Unity view (full screen)
          if (_isReady)
            UnityView(
              bridge: _bridge,
              config: UnityConfig(
                sceneName: 'GameShowroom',
                targetFrameRate: 60,
              ),
            ),

          // Loading overlay
          if (!_isReady || _isDownloading)
            Center(
              child: Column(
                mainAxisSize: MainAxisSize.min,
                children: [
                  const CircularProgressIndicator(),
                  const SizedBox(height: 16),
                  Text(
                    _isDownloading
                      ? 'Downloading model... ${(_downloadProgress * 100).toInt()}%'
                      : 'Initializing...',
                  ),
                ],
              ),
            ),

          // Error
          if (_errorMessage != null)
            Center(child: Text('Error: $_errorMessage')),
        ],
      ),
    );
  }

  @override
  void dispose() {
    _modelController.unloadModel();
    _bridge.dispose();
    super.dispose();
  }
}

/// Main game manager. Mount on a GameObject in the Core scene (persistent).
/// Coordinates: catalog update, remote config, shader warmup, readiness.
public class GameManager : MonoBehaviour
{
    [SerializeField] private ShaderVariantCollection shaderVariants;

    private CatalogUpdater _catalogUpdater;
    private RemoteConfigManager _remoteConfigManager;
    private DeviceTierDetector _tierDetector;

    private async void Start()
    {
        // 1. Detect device tier → set quality
        _tierDetector = new DeviceTierDetector();
        _tierDetector.ApplyQualitySettings();

        // 2. Shader warmup (eliminates stutter on first render)
        if (shaderVariants != null)
            shaderVariants.WarmUp();

        // 3. Catalog update (check for new content)
        _catalogUpdater = gameObject.AddComponent<CatalogUpdater>();
        await _catalogUpdater.CheckAndUpdate();

        // 4. Remote Config (fetch settings)
        _remoteConfigManager = gameObject.AddComponent<RemoteConfigManager>();
        await _remoteConfigManager.Initialize();

        // 5. Ready! Notify Flutter
        NativeAPI.SendToFlutter(JsonUtility.ToJson(new {
            type = "ready",
            deviceTier = _tierDetector.Tier.ToString(),
            catalogUpdated = _catalogUpdater.WasUpdated,
        }));
    }
}