import 'package:flutter/material.dart';
import 'package:outbag_app/backend/user.dart';
import 'package:outbag_app/screens/room/new.dart';
import './screens/home.dart';
import './screens/welcome.dart';
import './screens/room.dart';
import './screens/auth.dart';
import './backend/request.dart';
import 'package:routemaster/routemaster.dart';

// routes when user is not logged in
final routesUnauthorized = RouteMap(routes: {
    '/welcome/': (_) => const MaterialPage(child: WelcomePage()),
    '/signup': (_) => const MaterialPage(child: AuthPage(mode: Mode.signup)),
    '/signupOTA': (_) =>
    const MaterialPage(child: AuthPage(mode: Mode.signupOTA)),
    '/signin': (_) => const MaterialPage(child: AuthPage(mode: Mode.signin)),
  }, onUnknownRoute: (_) => const MaterialPage(child: WelcomePage()));

// routes when user is logged in
final routesLoggedIn = RouteMap(routes: {
    '/': (_) => const MaterialPage(child: HomePage()),
    '/new': (_) => const MaterialPage(child: NewRoomPage()),
    '/r/:server/:tag/:page?': (info) => MaterialPage(
      child: RoomPage(info.pathParameters['server'] ?? "",
        info.pathParameters['tag'] ?? "",
        page: info.pathParameters['page'] ?? ""),
    ),
    '/r/:server/:tag/': (info) => MaterialPage(
      child: RoomPage(info.pathParameters['server'] ?? "",
        info.pathParameters['tag'] ?? "",
        page: 'list'),
    ),
  }, onUnknownRoute: (_) => const Redirect('/'));

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  runApp(const OutbagApp());
}

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

  @override
  State<StatefulWidget> createState() => _OutbagAppState();
}

class _OutbagAppState extends State {
  // assume user is logged in
  // unless not userdata is found
  // or the userdata turns out to be wrong
  bool isAuthorized = true;

  @override
  void initState() {
    super.initState();

    // TODO: try to login user,
    // with existing details

    (() async {
        User credentials;
        try {
          credentials = await User.fromDisk();
        } catch (_) {
          // invalid credentials
          // log out
          setState(() {
              isAuthorized = false;
          });
          return;
        }
        try {
          final resp = await postUnauthorized(
            target: credentials.server,
            path: 'signin',
            body: {
              'name': credentials.username,
              'server': credentials.server.tag,
              'accountKey': credentials.password
          });
          if (resp.res == Result.ok) {
            setState(() {
                isAuthorized = true;
            });
          } else {
            // credentials are wrong
            // log out
            setState(() {
                isAuthorized = true;
            });
          }
        } catch (_) {
          // user is currently offline
          // approve login,
          // until user goes back offline
          // NOTE TODO: check user data once online
          setState(() {
              isAuthorized = true;
          });
        }
    })();

    // wait for user to be authorized
    User.listen((data) async {
        try {
          await User.fromDisk();
          setState(() {
              isAuthorized = true;
          });
        } catch (_) {}
    });
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp.router(
      title: "Outbag",
      // TODO: change back to system (or load from disk)
      //themeMode: ThemeMode.system,
      themeMode: ThemeMode.dark,
      theme: ThemeData(useMaterial3: true, brightness: Brightness.light),
      darkTheme: ThemeData(useMaterial3: true, brightness: Brightness.dark),
      routerDelegate: RoutemasterDelegate(
        routesBuilder: (context) =>
        isAuthorized ? routesLoggedIn : routesUnauthorized),
      routeInformationParser: const RoutemasterParser(),
    );
  }
}