import 'package:daciapackete/configproxyserver.dart';
import 'package:daciapackete/globals.dart' as globals;
import 'package:daciapackete/isarservice.dart';
import "package:daciapackete/mongodb.dart" as mongodb;
import 'package:daciapackete/speicherdaten.dart';
import 'package:flutter/material.dart';
import "showalertdialog.dart";

class FormServerConfig extends StatefulWidget {
  const FormServerConfig({super.key});

  @override
  State<FormServerConfig> createState() => _FormServerConfigState();
}

class _FormServerConfigState extends State<FormServerConfig> {
  // const themeBox = 'hiveThemeBox';
  // void main() async {
  // await Hive.initFlutter();
  // await Hive.openBox(themeBox);

  buttonText() {
    if (userErzeugt == true) {
      return "Test Anmeldung";
    } else {
      return "User Anlegen";
    }
  }

  titelText() {
    if (proxyValue == true) {
      return "Proxy ist Aktiv";
    } else {
      return "Proxy ist aus";
    }
  }

  datenSpeichern() {
    setState(() {
      globals.daciaAnmeldedaten.proxyBenutzen = proxyValue;
      globals.configProxyServer = configProxyServer;
      globals.configProxyServer.userErzeugt = userErzeugt;
      speicherDaten("proxydaten");
      Isarservice().saveConfigProxyServer(configProxyServer);
    });
  }

  ConfigProxyServer configProxyServer = globals.configProxyServer.copy();
  var proxyValue = globals.daciaAnmeldedaten.proxyBenutzen;
  var userErzeugt = globals.configProxyServer.userErzeugt;

  final _formKey = GlobalKey<FormState>();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(titelText()),
        actions: [
          Switch(
            activeColor: Colors.green,
            activeTrackColor: Colors.grey.shade400,
            inactiveThumbColor: Colors.red.shade600,
            inactiveTrackColor: Colors.grey.shade400,
            value: proxyValue,
            onChanged: (value) {
              //Hive.box(themeBox).put('darkMode', !value);
              if (proxyValue == true) {
                proxyValue = false;
                print("set False");
              } else {
                if (userErzeugt == false) {
                  showAlertDialog(
                      context, "Proxy Fehler", "Erst User Erzeugen", "ok");
                } else {
                  proxyValue = true;
                }
              }
              setState(() {});
            },
          ),
        ],
        //centerTitle: true,
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
      ),
      body: Center(
        child: SingleChildScrollView(
          child: Form(
            key: _formKey,
            child: Column(
              //mainAxisAlignment: MainAxisAlignment.start,
              children: [
                Card(
                  child: Padding(
                    padding: const EdgeInsets.all(8),
                    child: Column(
                      children: <Widget>[
                        const ListTile(
                          title: Text("Server Angaben"),
                        ),
                        //Switch
                        Card(
                          child: Padding(
                            padding: const EdgeInsets.all(8),
                            child: Column(
                              children: <Widget>[
                                Row(
                                  mainAxisAlignment:
                                      MainAxisAlignment.spaceBetween,
                                  children: [
                                    const Text("Datenbank-User angelegt"),
                                    Switch(
                                      activeColor: Colors.green,
                                      activeTrackColor: Colors.grey.shade400,
                                      inactiveThumbColor: Colors.red.shade600,
                                      inactiveTrackColor: Colors.grey.shade400,
                                      value: userErzeugt,
                                      onChanged: (val) {
                                        //Hive.box(themeBox).put('darkMode', !value);
                                        if (userErzeugt == true) {
                                          userErzeugt = false;
                                          proxyValue = false;
                                        } else {
                                          userErzeugt = true;
                                        }
                                        setState(() {});
                                      },
                                    ),
                                  ],
                                ),
                                if (userErzeugt == false) ...[
                                  TextFormField(
                                    autocorrect: false,
                                    keyboardType: TextInputType.text,
                                    decoration: const InputDecoration(
                                        labelText: "Öffentlicher User"),
                                    initialValue:
                                        (configProxyServer.userCreateUserName),
                                    validator: (ucu) {
                                      if (ucu!.isEmpty) {
                                        return 'Bitte einen Benutzernamen eingeben';
                                      }
                                      return null;
                                    },
                                    onChanged: (ucu) => setState(() =>
                                        configProxyServer.userCreateUserName =
                                            ucu),
                                  ),
                                  TextFormField(
                                    autocorrect: false,
                                    keyboardType: TextInputType.text,
                                    decoration: const InputDecoration(
                                        labelText:
                                            "Öffentlicher User Passwort"),
                                    initialValue: (configProxyServer
                                        .userCreateUserPasswort),
                                    // obscureText: true,
                                    onChanged: (ucupw) => setState(() =>
                                        configProxyServer
                                            .userCreateUserPasswort = ucupw),
                                  ),
                                ],
                              ],
                            ),
                            // ),
                            //neu ende
                          ),
                        ),
                        //Switch ende
                        TextFormField(
                          autocorrect: false,
                          keyboardType: TextInputType.text,
                          decoration:
                              const InputDecoration(labelText: "Login Name"),
                          initialValue: (configProxyServer.dbUserName),
                          validator: (dn) {
                            if (dn!.isEmpty) {
                              return 'Bitte einen Benutzernamen eingeben';
                            }
                            return null;
                          },
                          onChanged: (dn) =>
                              setState(() => configProxyServer.dbUserName = dn),
                        ),
                        TextFormField(
                          autocorrect: false,
                          keyboardType: TextInputType.text,
                          decoration:
                              const InputDecoration(labelText: "Passwort"),
                          initialValue: (configProxyServer.dbPasswort),
                          // obscureText: true,
                          onChanged: (dp) =>
                              setState(() => configProxyServer.dbPasswort = dp),
                        ),
                        TextFormField(
                          autocorrect: false,
                          keyboardType: TextInputType.text,
                          decoration:
                              const InputDecoration(labelText: "Adress-Name"),
                          initialValue: (configProxyServer.dbAdresse),
                          // obscureText: true,
                          onChanged: (dp) =>
                              setState(() => configProxyServer.dbAdresse = dp),
                        ),
                        TextFormField(
                          autocorrect: false,
                          keyboardType: TextInputType.text,
                          decoration: const InputDecoration(labelText: "Port"),
                          initialValue: (configProxyServer.dbPort),
                          //obscureText: true,
                          onChanged: (dp) =>
                              setState(() => configProxyServer.dbPort = dp),
                        ),

                        ElevatedButton(
                          child: Text(buttonText()),
                          onPressed: () async {
                            print(configProxyServer.toJson());
                            //if (userErzeugt == false) {
                              var (db, em) = await mongodb
                                  .openCreatorDB(configProxyServer);
                              if (em == null) {
                                var ergebnisErzeugungString =
                                    await mongodb.createMongoUserMitDb(
                                        db,
                                        configProxyServer.dbUserName,
                                        configProxyServer.dbPasswort);
                                if (ergebnisErzeugungString != "ok") {
                                  showAlertDialog(context, "Datenbank Problem",
                                      ergebnisErzeugungString, "ok");
                                } else {
                                  userErzeugt = true;
                                  setState(() {});
                                  datenSpeichern();
                                }
                              } else {
                                showDialog<String>(
                                  context: context,
                                  builder: (BuildContext context) =>
                                      AlertDialog(
                                    title: const Text('Datenbank Probleme'),
                                    content: Text(em),
                                    actions: <Widget>[
                                      TextButton(
                                        onPressed: () =>
                                            Navigator.pop(context, 'OK'),
                                        child: const Text('OK'),
                                      ),
                                    ],
                                  ),
                                );
                              }
                            } else {
                              var ergebnis =
                                  await mongodb.testeZugang(configProxyServer);
                              if (ergebnis == null) {
                                showAlertDialog(context, "Datenbank Test",
                                    "Alles ok", "ok");
                              } else {
                                showAlertDialog(context, "Datenbank Problem",
                                    ergebnis, "ok");
                              }
                            }
                          },

                        ),
                        if (userErzeugt == true) ...[
                          Row(
                            mainAxisAlignment: MainAxisAlignment.center,
                            children: <Widget>[
                              ElevatedButton(
                                child: const Text("Passwort Ändern"),
                                onPressed: () async {
                                  var (db, ergebnis) = await mongodb.openDB(
                                      globals.configProxyServer.dbAdresse,
                                      globals.configProxyServer.dbPort,
                                      globals.configProxyServer.dbUserName,
                                      globals.configProxyServer.dbPasswort,
                                      "admin");
                                  if (ergebnis == null) {
                                    var ergebnis1 =
                                        await mongodb.changeMongoUserPw(
                                            db,
                                            configProxyServer.dbUserName,
                                            configProxyServer.dbPasswort);
                                    print("ergebnis");
                                    print(ergebnis1);
                                    if (ergebnis1 == "ok") {
                                      datenSpeichern();
                                      showAlertDialog(context, "Datenbank",
                                          "Passwort Änderung ok.", "ok");
                                    } else {
                                      showAlertDialog(context, "Datenbank",
                                          ergebnis1, "ok");
                                    }
                                  } else {
                                    showAlertDialog(context,
                                        "Datenbank Problem", ergebnis, "ok");
                                  }
                                },
                               // child: const Text("Passwort Ändern"),
                              ),
                              ElevatedButton(
                                onPressed: () async {
                                  var (db, ergOpen) = await mongodb.openDB(
                                      globals.configProxyServer.dbAdresse,
                                      globals.configProxyServer.dbPort,
                                      globals.configProxyServer.dbUserName,
                                      globals.configProxyServer.dbPasswort,
                                      "admin");
                                  if (ergOpen == null) {
                                    var ergDelete =
                                        await mongodb.deleteMongoUser(
                                            db,
                                            configProxyServer.dbUserName,
                                            configProxyServer.dbPasswort);
                                    print("ergebnis");
                                    print(ergDelete);
                                    if (ergDelete == "ok") {
                                      userErzeugt = false;
                                      proxyValue = false;
                                      datenSpeichern();
                                      setState(() {});
                                      showAlertDialog(context, "Datenbank",
                                          "Löschen User ok.", "ok");
                                    } else {
                                      showAlertDialog(context, "Datenbank",
                                          ergDelete, "ok");
                                    }
                                  } else {
                                    showAlertDialog(context,
                                        "Datenbank Problem", ergOpen, "ok");
                                  }
                                },
                                child: const Text("User Löschen"),
                              ),
                            ],
                          ),
                        ],
                      ],
                    ),
                  ),
                ),
                Card(
                    child: Padding(
                        padding: const EdgeInsets.all(8),
                        child: Column(children: <Widget>[
                          Row(
                            mainAxisAlignment: MainAxisAlignment.center,
                            children: <Widget>[
                              ElevatedButton(
                                onPressed: () {
                                  _formKey.currentState?.reset();
                                  Navigator.pop(context, "abbruch");
                                },
                                child: const Text('Abbruch'),
                              ),
                              const SizedBox(width: 25),
                              ElevatedButton(
                                onPressed: () {
                                  if (_formKey.currentState!.validate()) {
                                    datenSpeichern();
                                    Navigator.pop(context, "Speichern");
                                  }
                                },
                                child: const Text('Speichern'),
                              )
                            ],
                          )
                        ])))
              ],
            ),
          ),
        ),
      ),
    );
  }
}
