import React, { useState, useEffect } from "react";
import { FormBuilder, Icon, Input, Alert, Loader } from "../../components/";
import { Backend, Config, Middleware } from "../../model/";
import { FormObjToJSON, notify, format, createFormBackend, objectGet, JSONStringify } from "../../helpers/";
import { t } from "../../locales/";

import "./backend.scss";

export class BackendPage extends React.Component {
    constructor(props) {
        super(props);
        this.state = {
            backend_enabled: [],
            backend_available: {},
            auth_enabled: null,
            auth_available: {},
            config: null,
            isLoading: true,
        };
    }

    componentDidMount() {
        Promise.all([
            Backend.all(),
            Config.all(),
            Middleware.getAllAuthentication(),
        ]).then((data) => {
            const [backend, config, middleware_auth] = data;
            delete config["constants"];
            this.setState({
                isLoading: false,
                backend_available: backend,
                backend_enabled: window.CONFIG["connections"].filter((b) => b).map((conn) => {
                    const f = createFormBackend(backend, conn);
                    if (Object.keys(f).length === 0) {
                        return null;
                    }
                    return f;
                }).filter((a) => a !== null),
                config: config,
                auth_available: middleware_auth,
                auth_enabled: {
                    // We are storing the config in a fixed schema as we had issues with handling
                    // different schema for each authentication middleware.
                    "identity_provider": (function() {
                        let { type, params } = objectGet(config, ["middleware", "identity_provider"]) || {};
                        type = objectGet(type, ["value"]);
                        params = objectGet(params, ["value"]);
                        if (!type) return {};
                        const idpParams = JSON.parse(params);
                        const idpForm = middleware_auth[type] || {};
                        let key = null;
                        for (key in idpParams) {
                            if (!idpForm[key]) continue;
                            idpForm[key]["value"] = idpParams[key];
                        }
                        return idpForm;
                    }()),
                    "attribute_mapping": (function(state) {
                        let { related_backend, params = {} } = objectGet(config, ["middleware", "attribute_mapping"]) || {};
                        related_backend = objectGet(related_backend, ["value"]);
                        params = JSON.parse(objectGet(params, ["value"]) || "{}");
                        const backendsForm = Object.keys(params).reduce((acc, key) => {
                            const t = createFormBackend(
                                backend,
                                params[key],
                            );
                            acc[key] = t[params[key]["type"]];
                            return acc;
                        }, {});
                        return {
                            "related_backend": {
                                "label": "Related Backend",
                                "type": "text",
                                "description": "List of backends to have behind the authentication process. Can be either a backend type of the actual label",
                                "placeholder": "eg: ftp,sftp,webdav",
                                "readonly": false,
                                "default": null,
                                "value": related_backend,
                                "multi": true,
                                "datalist": window.CONFIG["connections"].map((r) => r.label),
                                "required": true,
                            },
                            ...backendsForm,
                        };
                    })(),
                },
            });
        });
    }

    componentWillUnmount() {
        this.props.isSaving(false);
        Config.clear();
    }

    refresh() {
        // refresh the screen to refresh the mutation
        // that have happenned down the stack which react couldn't detect directly
        this.setState({ refresh: Math.random() });
    }

    _buildConfig() {
        const json = FormObjToJSON(this.state.config);
        json.connections = this.state.backend_enabled.map((backend) => {
            const data = FormObjToJSON(backend, (obj, key) => {
                if (obj[key].enabled === true) {
                    obj[key] = obj[key].value || obj[key].default;
                } else {
                    delete obj[key];
                }
            });
            const key = Object.keys(data)[0];
            return data[key];
        });
        return json;
    }

    onUpdateStorageBackend(e) {
        this.refresh();
        const json = this._buildConfig();
        this.props.isSaving(true);
        return Config.save(json, true, () => {
            this.props.isSaving(false);
        }, (err) => {
            notify.send(err && err.message || t("Oops"), "error");
            this.props.isSaving(false);
        });
    }

    onUpdateAuthenticationMiddleware(middlewareData = null) {
        this.refresh();
        const json = this._buildConfig();
        json["middleware"] = {
            "identity_provider": (function() {
                const { type, ...other } = objectGet(middlewareData, ["identity_provider"]) || {};
                return {
                    "type": type || null,
                    "params": JSONStringify(other),
                };
            })(),
            "attribute_mapping": (function() {
                let { related_backend = null, ...params } = objectGet(middlewareData, ["attribute_mapping"]) || {};
                const obj = {
                    "related_backend": related_backend || "nop"
                };
                if(Object.keys(params).length > 0) {
                    obj.params = JSONStringify(params);
                }
                return obj;
            })(),
        };

        this.props.isSaving(true);
        return Config.save(json, true, () => {
            this.props.isSaving(false);
        }, (err) => {
            notify.send(err && err.message || t("Oops"), "error");
            this.props.isSaving(false);
        });
    }

    addBackend(backend_id) {
        this.setState({
            backend_enabled: this.state.backend_enabled.concat(
                createFormBackend(this.state.backend_available, {
                    type: backend_id,
                    label: function() {
                        const existingLabels = this.state.backend_enabled
                              .filter((b) => !!b[backend_id])
                              .map((b) => b[backend_id]["label"]["value"]);

                        for (let i=1; i<=existingLabels.length; i++) {
                            const desiredLabel = backend_id.toUpperCase() + i;
                            if (existingLabels.indexOf(desiredLabel) === -1) {
                                return desiredLabel;
                            }
                        }
                        return backend_id.toUpperCase();
                    }.bind(this)(),
                }),
            ),
        }, this.onUpdateStorageBackend.bind(this));
    }

    removeBackend(n) {
        this.setState({
            backend_enabled: this.state.backend_enabled.filter((_, i) => i !== n),
        }, this.onUpdateStorageBackend.bind(this));
    }

    changeAuthentication(auth) {
        this.setState({
            auth_enabled: {
                "identity_provider": auth === null ? {} : this.state.auth_available[auth],
                "attribute_mapping": objectGet(this.state.auth_enabled, ["attribute_mapping"]) || {},
            },
        }, () => {
            this.onUpdateAuthenticationMiddleware(FormObjToJSON(this.state.auth_enabled));
        });
    }

    render() {
        const formRender = ($input, props, struct, onChange) => {
            if (struct.type === "enable") {
                // toggle buttons is to hide info from the login page
                // in this screen, we don't want users to have to click through too many things
                return null;
            }
            return (
                <label className={"no-select input_type_" + props.params["type"]}>
                    <div>
                        <span>
                            { format(struct.label) }:
                        </span>
                        <div style={{ width: "100%" }}>
                            { $input }
                        </div>
                    </div>
                    <div>
                        <span className="nothing"></span>
                        <div style={{ width: "100%" }}>
                            {
                                struct.description ? (
                                    <div className="description" dangerouslySetInnerHTML={{
                                        __html: function() {
                                            const regLink = /\[([^\]]*)\]\(([^\)]+)\)/g;
                                            return struct.description
                                                .replace(regLink, "<a target=\"_blank\" href=\"$2\">$1</a>")
                                                .replaceAll("\n", "<br>");
                                        }()
                                    }}></div>
                                ) : null
                            }
                        </div>
                    </div>
                </label>
            );
        };

        return (
            <div className="component_dashboard sticky">
                {
                    this.state.isLoading ? (
                        <Loader />
                    ) : (
                        <React.Fragment>
                            <StorageBackend
                                backend_available={this.state.backend_available}
                                backend_enabled={this.state.backend_enabled}
                                backend_add={this.addBackend.bind(this)}
                                backend_remove={this.removeBackend.bind(this)}
                                formChange={this.onUpdateStorageBackend.bind(this)}
                                formRender={formRender}
                            />
                            <br/><Alert className="info">
                                Once you have selected one or more storage backend, you can add some middleware to:<br/>
                                &nbsp;&nbsp;1. link the storage to an identity provider using an authentication middleware plugin<br/>
                                &nbsp;&nbsp;2. change who can do what and where using an authorisation middleware plugin<br/>
                                <br/>
                                <img
                                    style={{display: "block", margin: "0 auto", border: "none"}}
                                    src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!-- Do not edit this file with editors other than diagrams.net -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="393px" height="222px" viewBox="-0.5 -0.5 393 222" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2022-11-14T08:00:44.515Z&quot; agent=&quot;5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36&quot; etag=&quot;REHWLQNVk8jRhT1Meiis&quot; version=&quot;20.4.1&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;k57LS8GZpEZ4xsVlqrtw&quot; name=&quot;Page-1&quot;&gt;7Zpfc9o4EMA/DY9hbMvC8AgJSS9Dp+nRmbs+Glux1QiLEaLAffqTbPmvDLiJ3bgZJjMZaSVL1v52V9LiAbhdHx6Yuwk/Ux+RgWX4hwG4G1jWxATivxQcE4EDjEQQMOwnIjMXLPF/SAnTbjvso22pI6eUcLwpCz0aRcjjJZnLGN2Xuz1TUp514wZIEyw9l+jSf7DPw0Q6tpxc/gnhIExnNkeTpGXtpp3VSrah69N9QQTmA3DLKOVJaX24RUTqLtVL8tz9idbsxRiKeJMH8NcFCH+8sE/B49fHx8Ujv5+HN2qUny7ZqQWrl+XHVAPivTeyKGZyCUGEBsxdD8BsgxheI45Yte0pb5jtQ8zRcuN6coS9sBAhC/maiJopis/4gFLosu672xD5qrLljL6gW0ooi98ETGz5Fz9GSCqPaISyzikiodyZrp90sYhxdCiIlL4eEBWvzY6ii2oFtmJ3TI1S1fe5KYyUKCxawVgJXWV9QTZ0DkgUFKNf4GX1i9cbET3TiNc93AI6e9Q3dKA5ut2aTD0u1TKTK8YiHC3cFSJPdIs5ppHosqKc03Whw5TgQDZwWmFGd5zgSEBKA6TRC9+yqoCgqQECNYBGXfFxND7THQ/FAoV2Y6VXaYmF8rKqy1pV2qtRqKtYeWJ0xGogrrHvy2lq/ZHRXeTHUdKIa9xVNnEztpVTpS7qnHGyuJ9ajdFGsDQrQB2oATWtGqKgK6JjjeiT0Bb1KPloLNsImKBv+Ez9cHL/12I+sEZEsloxUQpkafnty9/Th/nJcOodRQD0EQOXN7hVwmOxygSu9xLElL4kcTQ1D0UF1lA6E1xP+eJvCroQViBbIw3ypG5XNOyuIPfsRNOzE6ht9O0YY+rnGLlPUoa3H3KbbGNndHoXWu3mXuftGDnOmIiDiF/2p1zrZo2SixQm58+h3VzoxrBEQsynk6iNf52RGGkkPsdWvRfr7KkvlWLk646b4sXFDDgKvsnryt0NaIlv5VKRbWYXwmV3jqbfKjSoKPKnMlMl6RB3u8XeKZcyavQtlMWO/6rGuPJdVoYWTOt3h2Lr3XFw6Qr4C66H/FL6TAdTUDysUXwqY4iIwPCznHSro6FmeKJYvMnpu0f1lrilO+Yh9VQxSVYdCFrDMXRM20r+T6rDDq1is1WehbssQFybJbacTCdvSP4YXRvTR7IJG8IKPPN1NmE7FwbqGnuDJO0Ve+bBE7udUGCbFwbqGnuDm9EVe+6klZ2/emJrjB1eGKhr7A3yxFfsuZO2hB1M3hl7gxvZFXt+TGsL+yX76Ro77Br7ifvBmcsByG4OhTxae1eGRKNndGL2y9ag2dI5EoJ3PkfqqYbfFmLQAfPMCEX5e6Gcm6CsSOU4UNXqDbCRmSVU/iAzAy2FNPjeIa1ByuMj5hahDYcVBx+PhzWZ3hobsowz9vK2D0b0H0GXnDL51ZNlyB+3hMdreK5pxgu/ylQvGzVpRtOp4fyKPKOo5t+IJT6af2gH5v8D&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><path d="M 81 181 L 101 1 L 141 1 L 121 181 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="6 6" pointer-events="all"/><path d="M 201 181 L 221 1 L 261 1 L 241 181 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><ellipse cx="16" cy="59.5" rx="7.5" ry="7.5" fill="none" stroke="#949494" stroke-width="2" pointer-events="all"/><path d="M 16 67 L 16 92 M 16 72 L 1 72 M 16 72 L 31 72 M 16 92 L 1 112 M 16 92 L 31 112" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><rect x="51" y="76" width="120" height="30" fill="none" stroke="none" transform="rotate(-84,111,91)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-84 111 91)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 91px; margin-left: 52px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Authentication</div></div></div></foreignObject><text x="111" y="96" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Authentication</text></switch></g><rect x="171" y="76" width="120" height="30" fill="none" stroke="none" transform="rotate(-84,231,91)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-84 231 91)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 91px; margin-left: 172px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Protocol</div></div></div></foreignObject><text x="231" y="96" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Protocol</text></switch></g><path d="M 291 42 C 291 33.72 311.15 27 336 27 C 347.93 27 359.38 28.58 367.82 31.39 C 376.26 34.21 381 38.02 381 42 L 381 116 C 381 124.28 360.85 131 336 131 C 311.15 131 291 124.28 291 116 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 381 42 C 381 50.28 360.85 57 336 57 C 311.15 57 291 50.28 291 42" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 92px; margin-left: 292px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">FILE<br />STORAGE</div></div></div></foreignObject><text x="336" y="97" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">FILE...</text></switch></g><path d="M 141 181 L 161 1 L 201 1 L 181 181 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="6 6" pointer-events="all"/><rect x="111" y="76" width="120" height="30" fill="none" stroke="none" transform="rotate(-84,171,91)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-84 171 91)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 91px; margin-left: 112px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Authorisation</div></div></div></foreignObject><text x="171" y="96" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Authorisation</text></switch></g><path d="M 136 140 L 133.5 140 Q 131 140 131 150 L 131 180 Q 131 190 128.5 190 L 127.25 190 Q 126 190 128.5 190 L 129.75 190 Q 131 190 131 200 L 131 230 Q 131 240 133.5 240 L 136 240" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" transform="rotate(-90,131,190)" pointer-events="all"/><rect x="101" y="191" width="60" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 205px; margin-left: 102px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Middleware</div></div></div></foreignObject><text x="131" y="210" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Middlew...</text></switch></g><path d="M 51 61 L 85.62 61.23" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 91.62 61.27 L 83.59 65.22 L 85.62 61.23 L 83.65 57.22 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 196 62 L 207.76 62" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 213.76 62 L 205.76 66 L 207.76 62 L 205.76 58 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 135 61 L 146.76 61" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 152.76 61 L 144.76 65 L 146.76 61 L 144.76 57 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 211 101 L 199.24 101" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 193.24 101 L 201.24 97 L 199.24 101 L 201.24 105 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 151 101 L 139.24 101" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 133.24 101 L 141.24 97 L 139.24 101 L 141.24 105 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 91 101 L 59.24 101" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 53.24 101 L 61.24 97 L 59.24 101 L 61.24 105 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 256 62 L 282.76 62" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 288.76 62 L 280.76 66 L 282.76 62 L 280.76 58 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 291 102 L 259.23 101.21" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 253.24 101.06 L 261.33 97.26 L 259.23 101.21 L 261.13 105.25 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 296.5 89.5 L 294 89.5 Q 291.5 89.5 291.5 99.5 L 291.5 180 Q 291.5 190 289 190 L 287.75 190 Q 286.5 190 289 190 L 290.25 190 Q 291.5 190 291.5 200 L 291.5 280.5 Q 291.5 290.5 294 290.5 L 296.5 290.5" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" transform="rotate(-90,291.5,190)" pointer-events="all"/><rect x="211" y="191" width="170" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 168px; height: 1px; padding-top: 205px; margin-left: 212px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Storage backend</div></div></div></foreignObject><text x="296" y="210" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Storage backend</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.diagrams.net/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>
"
                                />
                                ref: <a href="https://www.filestash.app/docs/plugin/">plugin documentation</a>
                            </Alert>
                            <AuthenticationMiddleware
                                authentication_available={this.state.auth_available}
                                authentication_enabled={this.state.auth_enabled}
                                authentication_update={this.changeAuthentication.bind(this)}
                                backend_available={this.state.backend_available}
                                backend_enabled={this.state.backend_enabled}
                                formChange={this.onUpdateAuthenticationMiddleware.bind(this)}
                                formRender={formRender}
                            />
                        </React.Fragment>
                    )
                }
            </div>
        );
    }
}

function StorageBackend({ backend_available, backend_enabled, backend_add, backend_remove, formChange, formRender }) {
    const isActiveBackend = (backend_key) => {
        return backend_enabled
            .map((b) => Object.keys(b)[0])
            .indexOf(backend_key) !== -1;
    };

    return (
        <div className="component_storagebackend">
            <h2>Storage Backend</h2>
            <div className="box-container">
                {
                    Object.keys(backend_available)
                        .sort((a, b) => a > b)
                        .map((backend_available_current, index) => (
                            <div
                                key={index}
                                onClick={() => backend_add(backend_available_current)}
                                className={"box-item pointer no-select" + (isActiveBackend(backend_available_current) ? " active": "")}>
                                <div>
                                    { backend_available_current }
                                    <span className="no-select">
                                        <span className="icon">+</span>
                                    </span>
                                </div>
                            </div>
                        ))
                }
            </div>
            {
                backend_enabled.length !== 0 ? (
                    <div>
                        <form>
                            {
                                backend_enabled.map((backend_enabled_current, index) => {
                                    return (
                                        <div key={index}>
                                            <div className="icons no-select"
                                                onClick={() => backend_remove(index)}>
                                                <Icon name="close" />
                                            </div>
                                            <FormBuilder
                                                onChange={formChange}
                                                idx={index}
                                                key={index}
                                                form={{ "": backend_enabled_current }}
                                                render={formRender} />
                                        </div>
                                    );
                                })
                            }
                        </form>
                    </div>
                ) : <Alert className="error">There is no storage selected. Where do you want to connect to?</Alert>
            }
        </div>
    );
}


function AuthenticationMiddleware({ authentication_available, authentication_enabled, backend_available, backend_enabled, authentication_update, formChange, formRender }) {
    const [formSpec, setFormSpec] = useState(authentication_enabled);
    const formChangeHandler = (e) => {
        formChange(e[""]);
    };

    useEffect(() => {
        setFormSpec(authentication_enabled);
    }, [authentication_enabled]);

    // we want to update the form in a few scenarios:
    // 1. user remove a storage backend
    // 2. user add a storage backend
    // 3. add a related backend in attribute mapping
    // 4. remove a related backend in attribute mapping

    // we want to update the form whenever a user change the related_backend input.
    // The change could be to either:
    // 1. add something to the list => create a new form in the attribute_mapping section
    // 2. remove something from the list => remove something in the attribute_mapping section
    useEffect(() => {
        if (!formSpec["identity_provider"]) return;

        const existingValues = (formSpec["attribute_mapping"]["related_backend"]["value"] || "")
            .split(/, ?/)
            .map((a) => a.trim());
        const { identity_provider, attribute_mapping } = formSpec;
        const selected = backend_enabled.map((b) => {
            const type = Object.keys(b)[0];
            return {
                label: b[type].label.value,
                type: Object.keys(b)[0],
            };
        });
        let needToSave = false;

        // detect missing form from the existing attribute_mapping
        // this happen whenever a user added something in the related_backend input
        for (let i=0; i<selected.length; i++) {
            if (attribute_mapping[selected[i].label]) continue;
            for (let j=0; j<existingValues.length; j++) {
                if (selected[i].label === existingValues[j]) {
                    attribute_mapping[selected[i].label] = JSON.parse(JSON.stringify(backend_available[selected[i].type]));
                    needToSave = true;
                }
            }
        }
        // detect out of date attribute_mapping that are still showing but shouldn't
        Object.keys(formSpec["attribute_mapping"]).map((key) => {
            if (key === "related_backend") return;
            if (existingValues.indexOf(key) !== -1) return;
            needToSave = true;
            delete attribute_mapping[key];
        });
        if (needToSave === false) return;
        const d = {
            identity_provider,
            attribute_mapping: attribute_mapping,
        };
        formChange(FormObjToJSON(d));
        setFormSpec(d);
    }, [
        formSpec["attribute_mapping"]["related_backend"]["value"],
        !formSpec["identity_provider"],
    ]);

    useEffect(() => { // autocompletion of the related_backend field
        const f = { ...formSpec };
        f.attribute_mapping.related_backend.datalist = backend_enabled
            .map((r) => r[Object.keys(r)[0]].label.value);

        const enabledBackendLabel = backend_enabled.map((b) => b[Object.keys(b)[0]].label.value);
        f.attribute_mapping.related_backend.value = (f.attribute_mapping.related_backend.value || "")
            .split(/, ?/)
            .filter((value) => enabledBackendLabel.indexOf(value) !== -1)
            .join(", ");

        setFormSpec(f);
    }, [backend_enabled]);

    const isActiveAuth = (auth_key) => {
        return auth_key === objectGet(authentication_enabled, ["identity_provider", "type", "value"]);
    };

    if (Object.keys(authentication_available).length === 0) return null;
    return (
        <div className="component_authenticationmiddleware" style={{ minHeight: "400px" }}>
            <h2>Authentication Middleware</h2>

            <div className="box-container">
                {
                    Object.keys(authentication_available)
                        .map((auth_current) => (
                            <div key={auth_current}
                                onClick={() => authentication_update(isActiveAuth(auth_current) ? null : auth_current)}
                                className={"box-item pointer no-select" + (isActiveAuth(auth_current) ? " active": "")}>
                                <div>
                                    { auth_current }
                                    <span className="no-select">
                                        <span className="icon">
                                            {
                                                isActiveAuth(auth_current) === false ?
                                                    "+" :
                                                    <Icon name="delete" />
                                            }
                                        </span>
                                    </span>
                                </div>
                            </div>
                        ))
                }
            </div>
            {
                objectGet(authentication_enabled, ["identity_provider", "type"]) && (
                    <div className="authentication-middleware">
                        <FormBuilder
                            onChange={formChangeHandler}
                            form={{ "": formSpec }}
                            render={formRender}
                        />
                    </div>
                )
            }
        </div>
    );
}