// Copyright 2018 Developers of the Rand project.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use crate::Error;

extern crate std;
// use std::thread_local;

// use js_sys::{global, Uint8Array};
// use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};

// Maximum is 65536 bytes see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
// const BROWSER_CRYPTO_BUFFER_SIZE: usize = 256;

// enum RngSource {
//     Node(NodeCrypto),
//     Browser(BrowserCrypto, Uint8Array),
// }

// // JsValues are always per-thread, so we initialize RngSource for each thread.
// //   See: https://github.com/rustwasm/wasm-bindgen/pull/955
// thread_local!(
//     static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
// );

pub(crate) fn getrandom_inner(_dest: &mut [u8]) -> Result<(), Error> {
    // RNG_SOURCE.with(|result| {
    //     let source = result.as_ref().map_err(|&e| e)?;
    //
    //     match source {
    //         RngSource::Node(n) => {
    //             if n.random_fill_sync(dest).is_err() {
    //                 return Err(Error::NODE_RANDOM_FILL_SYNC);
    //             }
    //         }
    //         RngSource::Browser(crypto, buf) => {
    //             // getRandomValues does not work with all types of WASM memory,
    //             // so we initially write to browser memory to avoid exceptions.
    //             for chunk in dest.chunks_mut(BROWSER_CRYPTO_BUFFER_SIZE) {
    //                 // The chunk can be smaller than buf's length, so we call to
    //                 // JS to create a smaller view of buf without allocation.
    //                 let sub_buf = buf.subarray(0, chunk.len() as u32);
    //
    //                 if crypto.get_random_values(&sub_buf).is_err() {
    //                     return Err(Error::WEB_GET_RANDOM_VALUES);
    //                 }
    //                 sub_buf.copy_to(chunk);
    //             }
    //         }
    //     };
    //     Ok(())
    // })
    Err(Error::UNSUPPORTED)
}

// fn getrandom_init() -> Result<RngSource, Error> {
//     let global: Global = global().unchecked_into();
//     if is_node(&global) {
//         let crypto = NODE_MODULE
//             .require("crypto")
//             .map_err(|_| Error::NODE_CRYPTO)?;
//         return Ok(RngSource::Node(crypto));
//     }
//
//     // Assume we are in some Web environment (browser or web worker). We get
//     // `self.crypto` (called `msCrypto` on IE), so we can call
//     // `crypto.getRandomValues`. If `crypto` isn't defined, we assume that
//     // we are in an older web browser and the OS RNG isn't available.
//     let crypto = match (global.crypto(), global.ms_crypto()) {
//         (c, _) if c.is_object() => c,
//         (_, c) if c.is_object() => c,
//         _ => return Err(Error::WEB_CRYPTO),
//     };
//
//     let buf = Uint8Array::new_with_length(BROWSER_CRYPTO_BUFFER_SIZE as u32);
//     Ok(RngSource::Browser(crypto, buf))
// }

// // Taken from https://www.npmjs.com/package/browser-or-node
// fn is_node(global: &Global) -> bool {
//     let process = global.process();
//     if process.is_object() {
//         let versions = process.versions();
//         if versions.is_object() {
//             return versions.node().is_string();
//         }
//     }
//     false
// }

// #[wasm_bindgen]
// extern "C" {
//     type Global; // Return type of js_sys::global()
//
//     // Web Crypto API (https://www.w3.org/TR/WebCryptoAPI/)
//     #[wasm_bindgen(method, getter, js_name = "msCrypto")]
//     fn ms_crypto(this: &Global) -> BrowserCrypto;
//     #[wasm_bindgen(method, getter)]
//     fn crypto(this: &Global) -> BrowserCrypto;
//     type BrowserCrypto;
//     #[wasm_bindgen(method, js_name = getRandomValues, catch)]
//     fn get_random_values(this: &BrowserCrypto, buf: &Uint8Array) -> Result<(), JsValue>;
//
//     // We use a "module" object here instead of just annotating require() with
//     // js_name = "module.require", so that Webpack doesn't give a warning. See:
//     //   https://github.com/rust-random/getrandom/issues/224
//     type NodeModule;
//     #[wasm_bindgen(js_name = module)]
//     static NODE_MODULE: NodeModule;
//     // Node JS crypto module (https://nodejs.org/api/crypto.html)
//     #[wasm_bindgen(method, catch)]
//     fn require(this: &NodeModule, s: &str) -> Result<NodeCrypto, JsValue>;
//     type NodeCrypto;
//     #[wasm_bindgen(method, js_name = randomFillSync, catch)]
//     fn random_fill_sync(this: &NodeCrypto, buf: &mut [u8]) -> Result<(), JsValue>;
//
//     // Node JS process Object (https://nodejs.org/api/process.html)
//     #[wasm_bindgen(method, getter)]
//     fn process(this: &Global) -> Process;
//     type Process;
//     #[wasm_bindgen(method, getter)]
//     fn versions(this: &Process) -> Versions;
//     type Versions;
//     #[wasm_bindgen(method, getter)]
//     fn node(this: &Versions) -> JsValue;
// }