// hook/build.dart
import 'package:native_assets_cli/native_assets_cli.dart';
import 'package:flutter_gpu_shaders/build.dart';

void main(List<String> args) async {
  await build(args, (input, output) async {
    await buildShaderBundleJson(
      buildInput: input,
      buildOutput: output,
      manifestFileName: 'shaders/simple.shaderbundle.json',
    );
  });
}

// main.dart
import 'dart:typed_data';

import 'package:flutter/material.dart';
import 'package:flutter_gpu/gpu.dart' as gpu;

void main() {
  runApp(const _CrashReproApp());
}

class _CrashReproApp extends StatelessWidget {
  const _CrashReproApp();

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: const Text('flutter_gpu Crash Repro')),
        body: const Center(
          child: _GpuDrawWidget(),
        ),
      ),
    );
  }
}

class _GpuDrawWidget extends StatefulWidget {
  const _GpuDrawWidget();

  @override
  State<_GpuDrawWidget> createState() => _GpuDrawWidgetState();
}

class _GpuDrawWidgetState extends State<_GpuDrawWidget> {
  String _status = 'Initializing...';

  @override
  void initState() {
    super.initState();
    // Schedule the GPU draw after the first frame so the widget tree is ready.
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _attemptGpuDraw();
    });
  }

  void _attemptGpuDraw() {
    try {
      // ----------------------------------------------------------
      // 1. Load the shader bundle compiled by hook/build.dart.
      // ----------------------------------------------------------
      final library = gpu.ShaderLibrary.fromAsset(
        'build/shaderbundles/simple.shaderbundle',
      );
      if (library == null) {
        setState(() => _status =
            'Failed to load shader bundle.\n'
            'Did you run: flutter pub get && flutter build?');
        return;
      }

      // ----------------------------------------------------------
      // 2. Get the vertex and fragment shaders.
      // ----------------------------------------------------------
      final vertShader = library['SimpleVertex'];
      final fragShader = library['SimpleFragment'];
      if (vertShader == null || fragShader == null) {
        setState(() => _status =
            'Shaders not found in bundle.\n'
            'Got vertex: ${vertShader != null}, '
            'fragment: ${fragShader != null}');
        return;
      }

      // ----------------------------------------------------------
      // 3. Create the render pipeline.
      // ----------------------------------------------------------
      final pipeline = gpu.gpuContext.createRenderPipeline(
        vertShader,
        fragShader,
      );

      // ----------------------------------------------------------
      // 4. Get the uniform slot for "FrameInfo" — the uniform block
      //    declared as: uniform FrameInfo { mat4 mvp; }
      // ----------------------------------------------------------
      final frameInfoSlot =
          pipeline.vertexShader.getUniformSlot('FrameInfo');

      // ----------------------------------------------------------
      // 5. Create a host buffer and write an identity matrix.
      //    16 floats = 1 mat4.
      // ----------------------------------------------------------
      final hostBuffer = gpu.gpuContext.createHostBuffer();
      final mvpData = Float32List.fromList(<double>[
        1, 0, 0, 0, //
        0, 1, 0, 0, //
        0, 0, 1, 0, //
        0, 0, 0, 1, //
      ]);
      final mvpView = hostBuffer.emplace(mvpData.buffer.asByteData());

      // ----------------------------------------------------------
      // 6. Create a 1×1 render target (minimal resource usage).
      // ----------------------------------------------------------
      final colorTexture = gpu.gpuContext.createTexture(
        gpu.StorageMode.devicePrivate,
        1,
        1,
      );
      if (colorTexture == null) {
        setState(() => _status = 'Failed to create color texture.');
        return;
      }
      final renderTarget = gpu.RenderTarget.singleColor(
        gpu.ColorAttachment(texture: colorTexture),
      );

      // ----------------------------------------------------------
      // 7. Create a command buffer and render pass.
      // ----------------------------------------------------------
      final commandBuffer = gpu.gpuContext.createCommandBuffer();
      final renderPass = commandBuffer.createRenderPass(renderTarget);

      // ----------------------------------------------------------
      // 8. Bind the uniform buffer.
      //
      //    This populates ShaderStructMemberMetadata with
      //    float_type = std::nullopt (the bug) for the mat4 member,
      //    because lib/gpu/shader_library.cc never sets float_type
      //    when deserializing flutter_gpu shader bundles.
      // ----------------------------------------------------------
      renderPass.bindUniform(frameInfoSlot, mvpView);

      // ----------------------------------------------------------
      // 9. Bind a minimal vertex buffer (a single triangle).
      // ----------------------------------------------------------
      final vertexData = Float32List.fromList(<double>[
        0.0, 0.5, 0.0, // vertex 0 position (vec3)
        -0.5, -0.5, 0.0, // vertex 1 position (vec3)
        0.5, -0.5, 0.0, // vertex 2 position (vec3)
      ]);
      final vertexView =
          hostBuffer.emplace(vertexData.buffer.asByteData());
      renderPass.bindVertexBuffer(vertexView, 3);

      // ----------------------------------------------------------
      // 10. Draw. On Windows GLES V2 this calls BindUniformBufferV2()
      //     which checks member.float_type.has_value(). Since
      //     float_type is std::nullopt for flutter_gpu shaders, this
      //     crashes with: "Float uniform should have a float type."
      // ----------------------------------------------------------
      renderPass.draw();

      // ----------------------------------------------------------
      // 11. Submit the command buffer.
      // ----------------------------------------------------------
      commandBuffer.submit();

      setState(() => _status =
          'GPU draw succeeded!\n\n'
          'If you see this, the bug has been fixed\n'
          'or you are not on Windows GLES V2.');
    } catch (e, st) {
      setState(() => _status =
          'CRASH (expected on Windows GLES V2):\n\n'
          '$e\n\nStack trace:\n$st');
    }
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(16),
      child: SelectableText(
        _status,
        style: const TextStyle(fontFamily: 'monospace', fontSize: 12),
      ),
    );
  }
}