import 'dart:ui';

import 'package:firebase_core/firebase_core.dart';
import 'package:go_router/go_router.dart';
import 'package:manager_api_new/api.dart';
import 'package:manager_app/Models/managerContext.dart';
import 'package:manager_app/Screens/Main/main_screen.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:responsive_framework/responsive_framework.dart';
import 'Components/common_loader.dart';
import 'Helpers/FileHelper.dart';
import 'Models/session.dart';
import 'Screens/Main/main_screen.dart';
import 'Screens/login_screen.dart';
import 'Screens/Policy/policy_screen.dart';
import 'app_context.dart';
import 'client.dart';
import 'constants.dart';
import 'package:flutter_web_plugins/url_strategy.dart';
import 'dart:html' as html;
//import 'package:window_size/window_size.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  var session = await loadJsonSessionFile();

  ManagerAppContext managerAppContext = ManagerAppContext();
  managerAppContext.instanceId = session.instanceId;

  await Firebase.initializeApp(
    // Replace with actual values
    options: FirebaseOptions(
      apiKey: "AIzaSyCFXuDsslqHiPpK6WTcxdIvTDP3ioaaxp4",
      authDomain: "mymuseum-3b97f.firebaseapp.com",
      projectId: "mymuseum-3b97f",
      storageBucket: "mymuseum-3b97f.appspot.com",
      messagingSenderId: "1034665398515",
      appId: "1:1034665398515:web:688e2a7b3465e621d6a786",
      measurementId: "G-EKKHJLJ1E9"
    ),
  );

  String? currentPath = html.window.location.pathname;

  usePathUrlStrategy();

  runApp(
      ChangeNotifierProvider<AppContext>(
        create: (_) => AppContext(managerAppContext),
        child: MaterialApp(
          home: FutureBuilder(
            future: getInstanceInfo(managerAppContext),
            builder: (context, asyncSnapshot) {
              if (asyncSnapshot.connectionState == ConnectionState.done) {
                var instanceDTO = asyncSnapshot.data;
                managerAppContext.instanceId = instanceDTO?.id;
                managerAppContext.instanceDTO = instanceDTO;

                String initialRoute = currentPath!.isNotEmpty ? currentPath : '/login';

                var _router = GoRouter(
                  initialLocation: initialRoute,
                  redirect: (context, state) {
                    var instanceId = managerAppContext.instanceId;
                    if (instanceId == null && state.fullPath != '/login') {
                      return '/login';
                    }


                    if (instanceId != null) {
                      if(state.fullPath == '/login' || state.fullPath == "") {
                        if(managerAppContext.instanceDTO!.isMobile!) {
                          return '/main/mobile';
                        }
                        if(managerAppContext.instanceDTO!.isTablet!) {
                          return '/main/tablet';
                        }
                        if(managerAppContext.instanceDTO!.isWeb!) {
                          return '/main/web';
                        }
                        if(managerAppContext.instanceDTO!.isVR!) {
                          return '/main/vr';
                        }
                      }
                      return state.matchedLocation;
                    }

                    return null;
                  },
                  routes: [
                    GoRoute(
                      path: '/login',
                      builder: (context, state) => LoginScreen(),
                    ),
                    GoRoute(
                      path: '/main/:view',
                      builder: (context, state) {
                        final view = state.pathParameters['view'];
                        return MainScreen(
                          instance: managerAppContext.instanceDTO!,
                          view: view,
                        );
                      },
                    ),
                    GoRoute(
                      path: '/policy',
                      builder: (context, state) => PolicyScreen(),
                    ),
                    GoRoute(
                      path: '/policy/mdlf',
                      builder: (context, state) => PolicyScreen(param: "mdlf"),
                    ),
                    GoRoute(
                      path: '/policy/fort',
                      builder: (context, state) => PolicyScreen(param: "fort"),
                    ),
                  ],
                  errorBuilder: (context, state) => MaterialApp(
                    home: Scaffold(
                      body: Center(
                        child: SizedBox(
                          width: MediaQuery.of(context).size.width * 0.85,
                          child: Text(
                            "404 - Cette page n'existe pas",
                            textAlign: TextAlign.center,
                            style: TextStyle(color: kPrimaryColor, fontSize: 20.0),
                          ),
                        ),
                      ),
                    ),
                  ),
                );

                return MyApp(
                    session: session,
                    managerAppContext: managerAppContext,
                    router: _router
                );
              } else if (asyncSnapshot.connectionState == ConnectionState.none) {
                return MaterialApp(
                  home: Scaffold(
                    body: Center(
                      child: SizedBox(
                        width: MediaQuery.of(context).size.width * 0.85,
                        child: Text(
                          "No data",
                          textAlign: TextAlign.center,
                          style: TextStyle(color: kPrimaryColor, fontSize: 20.0),
                        ),
                      ),
                    ),
                  ),
                );
              } else {
                return MaterialApp(
                  home: Scaffold(
                    body: Center(
                      child: SizedBox(
                        width: MediaQuery.of(context).size.width * 0.85,
                        child: Container(
                            height: 250,
                            child: CommonLoader()
                        ),
                      ),
                    ),
                  ),
                );
              }
            }
              ),
        ),
      )
  );
}

Future<InstanceDTO?> getInstanceInfo(ManagerAppContext managerAppContext) async {
  var session = await loadJsonSessionFile();

  try {
    managerAppContext.instanceId = managerAppContext.instanceId ?? session.instanceId;
    managerAppContext.host = managerAppContext.host ?? session.host;
    managerAppContext.accessToken = managerAppContext.accessToken ?? session.token;
    managerAppContext.email = managerAppContext.email ?? session.email;

    if(session.instanceId != null) {
      if(managerAppContext.clientAPI == null) {
        managerAppContext.clientAPI = Client(session.host!);
        managerAppContext.clientAPI!.apiApi!.addDefaultHeader('authorization', 'Bearer '+ managerAppContext.accessToken!);
      }

      InstanceDTO? instance = await managerAppContext.clientAPI!.instanceApi!.instanceGetDetail(managerAppContext.instanceId!);
      managerAppContext.instanceDTO = instance;
      return instance;
    }

    return null;
  } catch(e) {
    // todo
    /*Navigator.pushNamedAndRemoveUntil(
      context,
      '/login',
          (Route<dynamic> route) => false,
    );*/
    return null;
  }
}

class MyApp extends StatefulWidget {
  final Session session;
  final ManagerAppContext managerAppContext;
  final GoRouter router;
  MyApp({required this.session, required this.managerAppContext, required this.router});

  // This widget is the root of your application.
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final GlobalKey<_MyAppState> mainKey = GlobalKey();

  @override
  Widget build(BuildContext context) {
    return MaterialApp.router(
        routerConfig: widget.router,
        key: mainKey,
        builder: (context, child) => ResponsiveBreakpoints.builder(
          child: child!,
          breakpoints: [
            const Breakpoint(start: 0, end: 550, name: MOBILE),
            const Breakpoint(start: 550, end: 800, name: TABLET),
            const Breakpoint(start: 801, end: 1920, name: DESKTOP),
            const Breakpoint(start: 1921, end: double.infinity, name: '4K'),
          ],
        ),
        scrollBehavior: MyCustomScrollBehavior(),
        debugShowCheckedModeBanner: false,
        title: 'MyInfoMate - Manager',
        //initialRoute: widget.initialRoute,
        /*supportedLocales: [
          const Locale('en', 'US'),
          //const Locale('fr', 'FR'),
        ],*/
        theme: ThemeData(
          primarySwatch: Colors.blue,
          primaryColor: kPrimaryColor,
          scaffoldBackgroundColor: kBackgroundColor,
          //fontFamily: "Vollkorn",
          textTheme: TextTheme(bodyLarge: TextStyle(color: kBodyTextColor)),
          visualDensity: VisualDensity.adaptivePlatformDensity,
        ),
        /*routes: {
          '/login': (context) => LoginScreen(session: widget.session),
          '/main': (context) => MainScreen(),
          '/policy': (context) => PolicyScreen(),
          '/policy/mdlf': (context) => PolicyScreen(param: "mdlf"),
          '/policy/fort': (context) => PolicyScreen(param: "fort"),
        },
        onUnknownRoute: (settings) => MaterialPageRoute(
          builder: (context) => Container(child: Center(child: Text("Not found"))),
        ),*/
    );
  }
}

Future<Session> loadJsonSessionFile() async {
  Session session = await FileHelper().readSessionWeb();
  //print(session);
  return session;
}

class MyCustomScrollBehavior extends MaterialScrollBehavior {
  // Override behavior methods and getters like dragDevices
  @override
  Set<PointerDeviceKind> get dragDevices => {
    PointerDeviceKind.touch,
    PointerDeviceKind.mouse,
  };
}