// ignore_for_file: constant_identifier_names

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:oddisy_tabs_prototype/providers.dart';
import 'package:oddisy_tabs_prototype/test.dart';

void main() {
  runApp(const ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'Flutter Demo',
      theme: ThemeData.dark(),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  FocusNode currentTabFocusNode = FocusNode();
  List<TabObject> tabs = [
    TabObject(
      tabType: TabOjectType.CURRENT_PROJECT,
      tabName: 'Current Project',
    ),
    TabObject(
        tabType: TabOjectType.ENTRY,
        prefixImagePlaceholder: Icon(Icons.auto_awesome),
        tabName: 'test1'),
    // TabObject.createNew(),
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Consumer(builder: (context, ref, child) {
        // final tabs = ref.watch(tabsNotifierProvider);
        // if (tabs.isEmpty) {
        //   Future.delayed(
        //     Duration.zero,
        //     () => ref.read(tabsNotifierProvider.notifier).addTab(
        //         TabObject(tabType: TabOjectType.ENTRY, tabName: 'default')),
        //   );
        // }
        return CustomTabView(
            onAddPressed: () {
              // Future.delayed(
              //     Duration.zero,
              //     () => ref
              //         .read(tabsNotifierProvider.notifier)
              //         .addTab(TabObject(tabType: TabOjectType.EMPTY)));
              // tabs.add(TabObject(tabType: TabOjectType.EMPTY));

              // WidgetsBinding.instance?.addPostFrameCallback(
              //   (timeStamp) => setState(() {
              //     print(tabs.length);
              //     // tabs.add(TabObject(tabType: TabOjectType.EMPTY));
              //     // tabs.add(TabObject(tabType: TabOjectType.EMPTY));
              //     print(tabs.length);
              //   }),
              // );
              setState(() {
                tabs.add(TabObject(tabType: TabOjectType.EMPTY));
              });
            },
            onMiddleMouseButtonTapUp: (index) {
              // Future.delayed(
              //     Duration.zero,
              //     (() => ref
              //         .read(tabsNotifierProvider.notifier)
              //         .removeTabByIndex(index)));

              setState(() {
                tabs.removeAt(index);
              });
            },
            // onPositionChange: (value) {
            //   print(tabs[value].tabType);
            //   if (tabs[value].tabType == TabOjectType.CREATE_NEW) {
            //     print('create new tab pressed');
            //     setState(() {
            //       tabs[value] = TabObject(tabType: TabOjectType.EMPTY);
            //       tabs.add(TabObject.createNew());
            //     });
            //   }
            // },
            itemCount: tabs.length,
            tabBuilder: (context, index) {
              if (tabs[index].tabType == TabOjectType.CREATE_NEW) {
                return tabs[index].prefixImagePlaceholder;
              } else {
                return Row(
                  children: [
                    ConstrainedBox(
                        constraints:
                            const BoxConstraints(maxHeight: 25, maxWidth: 25),
                        child: tabs[index].prefixImagePlaceholder),
                    Padding(
                      padding: const EdgeInsets.symmetric(horizontal: 8),
                      child: Text('${tabs[index].tabName}'),
                    ),
                    TextButton(
                        style: TextButton.styleFrom(
                          padding: EdgeInsets.zero,
                          minimumSize: Size.zero,
                          tapTargetSize: MaterialTapTargetSize.shrinkWrap,
                          shape: BeveledRectangleBorder(
                              borderRadius: BorderRadius.circular(5)),
                        ),
                        onPressed: () {
                          if (index != 0) {
                            setState(() {
                              tabs.removeAt(index);
                            });
                          } else {
                            // TODO close whole project
                          }
                        },
                        child: const Icon(
                          Icons.close,
                          color: Colors.grey,
                        ))
                  ],
                );
              }
            },
            pageBuilder: (context, index) {
              return RawKeyboardListener(
                focusNode: currentTabFocusNode,
                onKey: (value) {
                  if (value is RawKeyDownEvent) {
                    if (value.isControlPressed &&
                        value.logicalKey == LogicalKeyboardKey.keyW) {
                      print('ctrl w pressed');
                      setState(() {
                        tabs.removeAt(index);
                      });
                    }
                  }
                },
                child: Center(
                  child: Text('tab $index'),
                ),
              );
            });
      }),
    );
  }
}

enum TabOjectType {
  CREATE_NEW,
  ENTRY,
  HIGH_LEVEL,
  HOME,
  CURRENT_PROJECT,
  EMPTY,
}

class TabObject {
  static TabObject createNew() {
    return TabObject(
        tabType: TabOjectType.CREATE_NEW,
        prefixImagePlaceholder: Icon(Icons.add),
        tabName: '');
  }

  Widget prefixImagePlaceholder;

  /// this is the optionally provided actual object which the tab is referencing -- such as the entry of an entry page or its id
  dynamic object;
  String? tabName;
  TabOjectType tabType;

  TabObject(
      {required this.tabType,
      this.prefixImagePlaceholder = const Placeholder(
        fallbackHeight: 10,
        fallbackWidth: 10,
      ),
      this.object,
      this.tabName});
}

class CustomTabView extends StatefulWidget {
  final int itemCount;
  final IndexedWidgetBuilder tabBuilder;
  final IndexedWidgetBuilder pageBuilder;
  final Widget? stub;
  final ValueChanged<int>? onPositionChange;
  final int? initPosition;
  final void Function(int tabIndexPosition)? onMiddleMouseButtonTapUp;
  final VoidCallback onAddPressed;

  /// referenced from https://stackoverflow.com/questions/50036546/how-to-create-a-dynamic-tabbarview-render-a-new-tab-with-a-function-in-flutter
  /// with edits for our usage
  const CustomTabView({
    required this.itemCount,
    required this.tabBuilder,
    required this.pageBuilder,
    this.stub,
    this.onPositionChange,
    this.initPosition,
    this.onMiddleMouseButtonTapUp,
    required this.onAddPressed,
  });

  @override
  _CustomTabViewState createState() => _CustomTabViewState();
}

class _CustomTabViewState extends State<CustomTabView>
    with TickerProviderStateMixin {
  late TabControllerCustom controller;
  late int _currentCount;
  late int _currentPosition;

  @override
  void initState() {
    _currentPosition = widget.initPosition ?? 0;
    controller = TabControllerCustom(
        length: widget.itemCount,
        vsync: this,
        initialIndex: _currentPosition,
        animationDuration: Duration.zero);
    // controller.addListener(onPositionChange);
    _currentCount = widget.itemCount;
    super.initState();
  }

  @override
  void didUpdateWidget(CustomTabView oldWidget) {
    print(
        'current count = $_currentCount and widget count = ${widget.itemCount}');
    if (_currentCount != widget.itemCount) {
      print('did not equal previous item count');
      // controller.removeListener(onPositionChange);
      final oldController = controller;
      // controller.dispose();

      if (widget.initPosition != null) {
        _currentPosition = widget.initPosition!;
      }

      if (_currentPosition >= widget.itemCount - 1) {
        _currentPosition = widget.itemCount - 1;
        _currentPosition = _currentPosition < 0 ? 0 : _currentPosition;
        if (widget.onPositionChange is ValueChanged<int>) {
          WidgetsBinding.instance?.addPostFrameCallback((_) {
            if (mounted) {
              // widget.onPositionChange!(_currentPosition);
            }
          });
        }
      }

      _currentCount = widget.itemCount;
      setState(() {
        controller = TabControllerCustom(
            length: widget.itemCount,
            vsync: this,
            initialIndex: _currentPosition,
            animationDuration: Duration.zero);
        // controller.addListener(onPositionChange);
      });
      print('controller index ${oldController.hasListeners}');
      oldController.dispose();
    } else if (widget.initPosition != null) {
      print('did equal previous item count');

      controller.animateTo(widget.initPosition!);
    }

    super.didUpdateWidget(oldWidget);
  }

  @override
  void dispose() {
    // controller.removeListener(onPositionChange);
    controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    if (widget.itemCount < 1) return widget.stub ?? Container();

    return Column(
      crossAxisAlignment: CrossAxisAlignment.stretch,
      children: <Widget>[
        Row(
          children: [
            Container(
              alignment: Alignment.centerLeft,
              child: GestureDetector(
                onTertiaryTapUp: (details) {
                  if (widget.onMiddleMouseButtonTapUp != null) {
                    widget.onMiddleMouseButtonTapUp!(_currentPosition);
                  }
                },
                child: TabBar(
                  padding: EdgeInsets.zero,
                  labelPadding: EdgeInsets.zero,
                  isScrollable: true,
                  controller: controller,
                  indicator: BoxDecoration(
                    color: Colors.grey.withOpacity(1),
                  ),
                  tabs: List.generate(
                    widget.itemCount,
                    (index) => widget.tabBuilder(context, index),
                  ),
                ),
              ),
            ),
            TextButton(
              onPressed: () {
                WidgetsBinding.instance?.addPostFrameCallback((timeStamp) {
                  widget.onAddPressed();
                });
              },
              child: const Icon(Icons.add),
              style: TextButton.styleFrom(
                padding: EdgeInsets.zero,
                minimumSize: Size.zero,
                tapTargetSize: MaterialTapTargetSize.shrinkWrap,
                shape: BeveledRectangleBorder(
                    borderRadius: BorderRadius.circular(5)),
              ),
            )
          ],
        ),
        Expanded(
          child: TabBarView(
            controller: controller,
            children: List.generate(
              widget.itemCount,
              (index) => widget.pageBuilder(context, index),
            ),
          ),
        ),
      ],
    );
  }

  // onPositionChange() {
  //   if (!controller.indexIsChanging) {
  //     _currentPosition = controller.index;
  //     if (widget.onPositionChange is ValueChanged<int>) {
  //       widget.onPositionChange!(_currentPosition);
  //     }
  //   }
  // }
}

import 'package:flutter/animation.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';

class TabControllerCustom extends TabController {
  TabControllerCustom(
      {int initialIndex = 0,
      Duration? animationDuration,
      required this.length,
      required TickerProvider vsync})
      : assert(length != null && length >= 0),
        assert(initialIndex != null &&
            initialIndex >= 0 &&
            (length == 0 || initialIndex < length)),
        _index = initialIndex,
        _previousIndex = initialIndex,
        _animationDuration = animationDuration ?? kTabScrollDuration,
        _animationController = AnimationController.unbounded(
          value: initialIndex.toDouble(),
          vsync: vsync,
        ),
        super(
            length: length,
            vsync: vsync,
            animationDuration: animationDuration,
            initialIndex: initialIndex);

  Animation<double>? get animation => _animationController?.view;
  AnimationController? _animationController;

  Duration get animationDuration => _animationDuration;
  final Duration _animationDuration;

  final int length;

  void _changeIndex(int value, {Duration? duration, Curve? curve}) {
    assert(value != null);
    assert(value >= 0 && (value < length || length == 0));
    assert(duration != null || curve == null);
    assert(_indexIsChangingCount >= 0);
    if (value == _index || length < 2) return;
    _previousIndex = index;
    _index = value;
    if (duration != null && duration > Duration.zero) {
      // _indexIsChangingCount += 1;
      // notifyListeners(); // Because the value of indexIsChanging may have changed.
      // _animationController!
      //     .animateTo(_index.toDouble(), duration: duration, curve: curve!)
      //     .whenCompleteOrCancel(() {
      //   if (_animationController != null) {
      //     // don't notify if we've been disposed
      //     _indexIsChangingCount -= 1;
      //     notifyListeners();
      //   }
      // });
    } else {
      _indexIsChangingCount += 1;
      if (_animationController != null) {
        _animationController!.value = _index.toDouble();
      }
      _indexIsChangingCount -= 1;
      notifyListeners();
    }
  }

  int get index => _index;
  int _index;
  set index(int value) {
    WidgetsBinding.instance?.addPostFrameCallback(
      (timeStamp) {
        _changeIndex(value);
      },
    );
  }

  int get previousIndex => _previousIndex;
  int _previousIndex;

  bool get indexIsChanging => _indexIsChangingCount != 0;
  int _indexIsChangingCount = 0;

  void animateTo(int value, {Duration? duration, Curve curve = Curves.ease}) {
    _changeIndex(value, duration: duration ?? _animationDuration, curve: curve);
  }

  double get offset => _animationController!.value - _index.toDouble();
  set offset(double value) {
    assert(value != null);
    assert(value >= -1.0 && value <= 1.0);
    assert(!indexIsChanging);
    if (value == offset) return;
    _animationController!.value = value + _index.toDouble();
  }

  @override
  void dispose() {
    print('controller dispose called and has listeners is $hasListeners');
    _animationController?.dispose();
    _animationController = null;
    super.dispose();
  }
}