// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:convert';
import 'dart:ffi';
import 'dart:io';
import 'dart:typed_data';
import 'package:ffi/ffi.dart';
import 'package:path/path.dart' as path;
import 'wasmer_api.dart';

class WasmImportDescriptor {
  int kind;
  String moduleName;
  String name;
  WasmImportDescriptor(this.kind, this.moduleName, this.name);
}

class WasmExportDescriptor {
  int kind;
  String name;
  WasmExportDescriptor(this.kind, this.name);
}

class WasmRuntime {
  static WasmRuntime? _inst;

  DynamicLibrary _lib;
  late WasmerCompileFn _compile;
  late WasmerInstantiateFn _instantiate;
  late WasmerInstanceExportsFn _instance_exports;
  late WasmerExportsLenFn _exports_len;
  late WasmerExportsGetFn _exports_get;
  late WasmerExportKindFn _export_kind;
  late WasmerExportToFuncFn _export_to_func;
  late WasmerExportFuncReturnsArityFn _export_func_returns_arity;
  late WasmerExportFuncReturnsFn _export_func_returns;
  late WasmerExportFuncParamsArityFn _export_func_params_arity;
  late WasmerExportFuncParamsFn _export_func_params;
  late WasmerExportFuncCallFn _export_func_call;
  late WasmerExportNamePtrFn _export_name_ptr;
  late WasmerExportDescriptorsFn _export_descriptors;
  late WasmerExportDescriptorsDestroyFn _export_descriptors_destroy;
  late WasmerExportDescriptorsLenFn _export_descriptors_len;
  late WasmerExportDescriptorsGetFn _export_descriptors_get;
  late WasmerExportDescriptorKindFn _export_descriptor_kind;
  late WasmerExportDescriptorNamePtrFn _export_descriptor_name_ptr;
  late WasmerImportDescriptorModuleNamePtrFn _import_descriptor_module_name_ptr;
  late WasmerImportDescriptorNamePtrFn _import_descriptor_name_ptr;
  late WasmerImportDescriptorsFn _import_descriptors;
  late WasmerImportDescriptorsDestroyFn _import_descriptors_destroy;
  late WasmerImportDescriptorsLenFn _import_descriptors_len;
  late WasmerImportDescriptorsGetFn _import_descriptors_get;
  late WasmerImportDescriptorKindFn _import_descriptor_kind;
  late WasmerExportToMemoryFn _export_to_memory;
  late WasmerMemoryNewPtrFn _memory_new_ptr;
  late WasmerMemoryGrowFn _memory_grow;
  late WasmerMemoryLengthFn _memory_length;
  late WasmerMemoryDataFn _memory_data;
  late WasmerMemoryDataLengthFn _memory_data_length;

  factory WasmRuntime() {
    if (_inst == null) {
      _inst = WasmRuntime._init();
    }
    return _inst as WasmRuntime;
  }

  static String _getLibName() {
    if (Platform.isMacOS) return "libwasmer_wrapper.dylib";
    if (Platform.isLinux) return "libwasmer_wrapper.so";
    throw Exception("Wasm not currently supported on this platform");
  }

  static String _getLibDir() {
    // The common case, and how cli_util.dart computes the Dart SDK directory,
    // path.dirname called twice on Platform.resolvedExecutable.
    var commonLibDir = path.join(
        path.absolute(path.dirname(path.dirname(Platform.resolvedExecutable))),
        'bin',
        'third_party',
        'wasmer');
    if (Directory(commonLibDir).existsSync()) {
      return commonLibDir;
    }

    // This is the less common case where the user is in the checked out Dart
    // SDK, and is executing dart via:
    // ./out/ReleaseX64/dart ...
    var checkedOutLibDir = path.join(
        path.absolute(path.dirname(Platform.resolvedExecutable)),
        'dart-sdk',
        'bin',
        'third_party',
        'wasmer');
    if (Directory(checkedOutLibDir).existsSync()) {
      return checkedOutLibDir;
    }

    // If neither returned above, we return the common case:
    return commonLibDir;
  }

  WasmRuntime._init()
      : _lib = DynamicLibrary.open(path.join(_getLibDir(), _getLibName())) {
    _compile = _lib.lookupFunction<NativeWasmerCompileFn, WasmerCompileFn>(
        'wasmer_compile');
    _instantiate =
        _lib.lookupFunction<NativeWasmerInstantiateFn, WasmerInstantiateFn>(
            'wasmer_module_instantiate');
    _instance_exports = _lib.lookupFunction<NativeWasmerInstanceExportsFn,
        WasmerInstanceExportsFn>('wasmer_instance_exports');
    _exports_len =
        _lib.lookupFunction<NativeWasmerExportsLenFn, WasmerExportsLenFn>(
            'wasmer_exports_len');
    _exports_get =
        _lib.lookupFunction<NativeWasmerExportsGetFn, WasmerExportsGetFn>(
            'wasmer_exports_get');
    _export_kind =
        _lib.lookupFunction<NativeWasmerExportKindFn, WasmerExportKindFn>(
            'wasmer_export_kind');
    _export_to_func =
        _lib.lookupFunction<NativeWasmerExportToFuncFn, WasmerExportToFuncFn>(
            'wasmer_export_to_func');
    _export_func_returns_arity = _lib.lookupFunction<
        NativeWasmerExportFuncReturnsArityFn,
        WasmerExportFuncReturnsArityFn>('wasmer_export_func_returns_arity');
    _export_func_returns = _lib.lookupFunction<NativeWasmerExportFuncReturnsFn,
        WasmerExportFuncReturnsFn>('wasmer_export_func_returns');
    _export_func_params_arity = _lib.lookupFunction<
        NativeWasmerExportFuncParamsArityFn,
        WasmerExportFuncParamsArityFn>('wasmer_export_func_params_arity');
    _export_func_params = _lib.lookupFunction<NativeWasmerExportFuncParamsFn,
        WasmerExportFuncParamsFn>('wasmer_export_func_params');
    _export_func_call = _lib.lookupFunction<NativeWasmerExportFuncCallFn,
        WasmerExportFuncCallFn>('wasmer_export_func_call');
    _export_descriptors = _lib.lookupFunction<NativeWasmerExportDescriptorsFn,
        WasmerExportDescriptorsFn>('wasmer_export_descriptors');
    _export_descriptors_destroy = _lib.lookupFunction<
        NativeWasmerExportDescriptorsDestroyFn,
        WasmerExportDescriptorsDestroyFn>('wasmer_export_descriptors_destroy');
    _export_descriptors_len = _lib.lookupFunction<
        NativeWasmerExportDescriptorsLenFn,
        WasmerExportDescriptorsLenFn>('wasmer_export_descriptors_len');
    _export_descriptors_get = _lib.lookupFunction<
        NativeWasmerExportDescriptorsGetFn,
        WasmerExportDescriptorsGetFn>('wasmer_export_descriptors_get');
    _export_descriptor_kind = _lib.lookupFunction<
        NativeWasmerExportDescriptorKindFn,
        WasmerExportDescriptorKindFn>('wasmer_export_descriptor_kind');
    _export_name_ptr =
        _lib.lookupFunction<NativeWasmerExportNamePtrFn, WasmerExportNamePtrFn>(
            'wasmer_export_name_ptr');
    _export_descriptor_name_ptr = _lib.lookupFunction<
        NativeWasmerExportDescriptorNamePtrFn,
        WasmerExportDescriptorNamePtrFn>('wasmer_export_descriptor_name_ptr');
    _import_descriptors = _lib.lookupFunction<NativeWasmerImportDescriptorsFn,
        WasmerImportDescriptorsFn>('wasmer_import_descriptors');
    _import_descriptors_destroy = _lib.lookupFunction<
        NativeWasmerImportDescriptorsDestroyFn,
        WasmerImportDescriptorsDestroyFn>('wasmer_import_descriptors_destroy');
    _import_descriptors_len = _lib.lookupFunction<
        NativeWasmerImportDescriptorsLenFn,
        WasmerImportDescriptorsLenFn>('wasmer_import_descriptors_len');
    _import_descriptors_get = _lib.lookupFunction<
        NativeWasmerImportDescriptorsGetFn,
        WasmerImportDescriptorsGetFn>('wasmer_import_descriptors_get');
    _import_descriptor_kind = _lib.lookupFunction<
        NativeWasmerImportDescriptorKindFn,
        WasmerImportDescriptorKindFn>('wasmer_import_descriptor_kind');
    _import_descriptor_module_name_ptr = _lib.lookupFunction<
            NativeWasmerImportDescriptorModuleNamePtrFn,
            WasmerImportDescriptorModuleNamePtrFn>(
        'wasmer_import_descriptor_module_name_ptr');
    _import_descriptor_name_ptr = _lib.lookupFunction<
        NativeWasmerImportDescriptorNamePtrFn,
        WasmerImportDescriptorNamePtrFn>('wasmer_import_descriptor_name_ptr');
    _export_to_memory = _lib.lookupFunction<NativeWasmerExportToMemoryFn,
        WasmerExportToMemoryFn>('wasmer_export_to_memory');
    _memory_new_ptr =
        _lib.lookupFunction<NativeWasmerMemoryNewPtrFn, WasmerMemoryNewPtrFn>(
            'wasmer_memory_new_ptr');
    _memory_grow =
        _lib.lookupFunction<NativeWasmerMemoryGrowFn, WasmerMemoryGrowFn>(
            'wasmer_memory_grow');
    _memory_length =
        _lib.lookupFunction<NativeWasmerMemoryLengthFn, WasmerMemoryLengthFn>(
            'wasmer_memory_length');
    _memory_data =
        _lib.lookupFunction<NativeWasmerMemoryDataFn, WasmerMemoryDataFn>(
            'wasmer_memory_data');
    _memory_data_length = _lib.lookupFunction<NativeWasmerMemoryDataLengthFn,
        WasmerMemoryDataLengthFn>('wasmer_memory_data_length');
  }

  Pointer<WasmerModule> compile(Uint8List data) {
    var dataPtr = allocate<Uint8>(count: data.length);
    for (int i = 0; i < data.length; ++i) {
      dataPtr[i] = data[i];
    }

    var modulePtrPtr = allocate<Pointer<WasmerModule>>();
    int result = _compile(modulePtrPtr, dataPtr, data.length);
    Pointer<WasmerModule> modulePtr = modulePtrPtr.value;

    free(modulePtrPtr);
    free(dataPtr);

    if (result != WasmerResultOk) {
      throw Exception("Wasm module compile failed");
    }

    return modulePtr;
  }

  String _callStringWrapperFunction(Function fn, dynamic arg) {
    var strPtr = allocate<WasmerByteArray>();
    fn(arg, strPtr);
    var str = strPtr.ref.string;
    free(strPtr);
    return str;
  }

  List<WasmExportDescriptor> exportDescriptors(Pointer<WasmerModule> module) {
    var exportsPtrPtr = allocate<Pointer<WasmerExportDescriptors>>();
    _export_descriptors(module, exportsPtrPtr);
    Pointer<WasmerExportDescriptors> exportsPtr = exportsPtrPtr.value;
    free(exportsPtrPtr);
    var n = _export_descriptors_len(exportsPtr);
    var exps = <WasmExportDescriptor>[];
    for (var i = 0; i < n; ++i) {
      var exp = _export_descriptors_get(exportsPtr, i);
      exps.add(WasmExportDescriptor(_export_descriptor_kind(exp),
          _callStringWrapperFunction(_export_descriptor_name_ptr, exp)));
    }
    _export_descriptors_destroy(exportsPtr);
    return exps;
  }

  List<WasmImportDescriptor> importDescriptors(Pointer<WasmerModule> module) {
    var importsPtrPtr = allocate<Pointer<WasmerImportDescriptors>>();
    _import_descriptors(module, importsPtrPtr);
    Pointer<WasmerImportDescriptors> importsPtr = importsPtrPtr.value;
    free(importsPtrPtr);

    var n = _import_descriptors_len(importsPtr);
    var imps = <WasmImportDescriptor>[];
    for (var i = 0; i < n; ++i) {
      var imp = _import_descriptors_get(importsPtr, i);
      imps.add(WasmImportDescriptor(
          _import_descriptor_kind(imp),
          _callStringWrapperFunction(_import_descriptor_module_name_ptr, imp),
          _callStringWrapperFunction(_import_descriptor_name_ptr, imp)));
    }
    _import_descriptors_destroy(importsPtr);
    return imps;
  }

  Pointer<WasmerInstance> instantiate(Pointer<WasmerModule> module,
      Pointer<WasmerImport> imports, int numImports) {
    var instancePtrPtr = allocate<Pointer<WasmerInstance>>();
    int result = _instantiate(module, instancePtrPtr, imports, numImports);
    Pointer<WasmerInstance> instancePtr = instancePtrPtr.value;
    free(instancePtrPtr);

    if (result != WasmerResultOk) {
      throw Exception("Wasm module instantiation failed");
    }

    return instancePtr;
  }

  List<Pointer<WasmerExport>> exports(Pointer<WasmerInstance> instancePtr) {
    var exportsPtrPtr = allocate<Pointer<WasmerExports>>();
    _instance_exports(instancePtr, exportsPtrPtr);
    Pointer<WasmerExports> exportsPtr = exportsPtrPtr.value;
    free(exportsPtrPtr);

    var n = _exports_len(exportsPtr);
    var exps = <Pointer<WasmerExport>>[];
    for (var i = 0; i < n; ++i) {
      exps.add(_exports_get(exportsPtr, i));
    }
    return exps;
  }

  int exportKind(Pointer<WasmerExport> export) {
    return _export_kind(export);
  }

  String exportName(Pointer<WasmerExport> export) {
    return _callStringWrapperFunction(_export_name_ptr, export);
  }

  Pointer<WasmerExportFunc> exportToFunction(Pointer<WasmerExport> export) {
    return _export_to_func(export);
  }

  List<int> getArgTypes(Pointer<WasmerExportFunc> func) {
    var types = <int>[];
    var nPtr = allocate<Uint32>();
    var result = _export_func_params_arity(func, nPtr);
    if (result != WasmerResultOk) {
      free(nPtr);
      throw Exception("Failed to get number of WASM function args");
    }
    var n = nPtr.value;
    free(nPtr);
    var argsPtr = allocate<Uint32>(count: n);
    result = _export_func_params(func, argsPtr, n);
    if (result != WasmerResultOk) {
      free(argsPtr);
      throw Exception("Failed to get WASM function args");
    }
    for (var i = 0; i < n; ++i) {
      types.add(argsPtr[i]);
    }
    free(argsPtr);
    return types;
  }

  int getReturnType(Pointer<WasmerExportFunc> func) {
    var nPtr = allocate<Uint32>();
    var result = _export_func_returns_arity(func, nPtr);
    if (result != WasmerResultOk) {
      free(nPtr);
      throw Exception("Failed to get number of WASM function returns");
    }
    var n = nPtr.value;
    free(nPtr);
    if (n == 0) {
      return WasmerValueTagVoid;
    } else if (n > 1) {
      throw Exception("Multiple return values are not supported");
    }
    var returnsPtr = allocate<Uint32>();
    result = _export_func_returns(func, returnsPtr, 1);
    if (result != WasmerResultOk) {
      free(returnsPtr);
      throw Exception("Failed to get WASM function args");
    }
    var type = returnsPtr.value;
    free(returnsPtr);
    return type;
  }

  void call(Pointer<WasmerExportFunc> func, Pointer<WasmerValue> args,
      int numArgs, Pointer<WasmerValue> results, int numResults) {
    var result = _export_func_call(func, args, numArgs, results, numArgs);
    if (result != WasmerResultOk) {
      throw Exception("Failed to call WASM function");
    }
  }

  Pointer<WasmerMemory> exportToMemory(Pointer<WasmerExport> export) {
    var memPtrPtr = allocate<Pointer<WasmerMemory>>();
    var result = _export_to_memory(export, memPtrPtr);
    if (result != WasmerResultOk) {
      free(memPtrPtr);
      throw Exception("Failed to get exported memory");
    }
    Pointer<WasmerMemory> memPtr = memPtrPtr.value;
    free(memPtrPtr);
    return memPtr;
  }

  Pointer<WasmerMemory> newMemory(int pages, int? maxPages) {
    var memPtrPtr = allocate<Pointer<WasmerMemory>>();
    var limPtr = allocate<WasmerLimits>();
    limPtr.ref.min = pages;
    limPtr.ref.has_max = maxPages != null ? 1 : 0;
    limPtr.ref.max = maxPages ?? 0;
    var result = _memory_new_ptr(memPtrPtr, limPtr);
    free(limPtr);
    if (result != WasmerResultOk) {
      free(memPtrPtr);
      throw Exception("Failed to create memory");
    }
    Pointer<WasmerMemory> memPtr = memPtrPtr.value;
    free(memPtrPtr);
    return memPtr;
  }

  void growMemory(Pointer<WasmerMemory> memory, int deltaPages) {
    var result = _memory_grow(memory, deltaPages);
    if (result != WasmerResultOk) {
      throw Exception("Failed to grow memory");
    }
  }

  int memoryLength(Pointer<WasmerMemory> memory) {
    return _memory_length(memory);
  }

  Uint8List memoryView(Pointer<WasmerMemory> memory) {
    return _memory_data(memory).asTypedList(_memory_data_length(memory));
  }
}