import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_svg/svg.dart';
import 'package:syncrow_web/common/widgets/search_bar.dart';
import 'package:syncrow_web/common/widgets/sidebar_communities_list.dart';
import 'package:syncrow_web/pages/space_tree/bloc/space_tree_bloc.dart';
import 'package:syncrow_web/pages/space_tree/bloc/space_tree_event.dart';
import 'package:syncrow_web/pages/space_tree/bloc/space_tree_state.dart';
import 'package:syncrow_web/pages/space_tree/view/custom_expansion.dart';
import 'package:syncrow_web/pages/spaces_management/all_spaces/model/community_model.dart';
import 'package:syncrow_web/pages/spaces_management/all_spaces/model/space_model.dart';
import 'package:syncrow_web/utils/color_manager.dart';
import 'package:syncrow_web/utils/constants/assets.dart';
import 'package:syncrow_web/utils/extension/build_context_x.dart';
import 'package:syncrow_web/utils/style.dart';

class SpaceTreeView extends StatefulWidget {
  final bool? isSide;
  final Function onSelect;
  final bool shouldDisableDeselectingChildrenOfSelectedParent;
  final Widget? title;
  const SpaceTreeView({
    required this.onSelect,
    this.isSide,
    super.key,
    this.shouldDisableDeselectingChildrenOfSelectedParent = false,
    this.title,
  });

  @override
  State<SpaceTreeView> createState() => _SpaceTreeViewState();
}

class _SpaceTreeViewState extends State<SpaceTreeView> {
  late final ScrollController _scrollController;

  @override
  void initState() {
    _scrollController = ScrollController();
    super.initState();
  }

  @override
  void dispose() {
    _scrollController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return BlocBuilder<SpaceTreeBloc, SpaceTreeState>(
        builder: (context, state) {
      final communities = state.searchQuery.isNotEmpty
          ? state.filteredCommunity
          : state.communityList;
      return Container(
        height: MediaQuery.sizeOf(context).height,
        decoration: widget.isSide == true
            ? subSectionContainerDecoration.copyWith(
                color: ColorsManager.whiteColors)
            : const BoxDecoration(color: ColorsManager.whiteColors),
        child: state is SpaceTreeLoadingState
            ? const Center(child: CircularProgressIndicator())
            : Column(
                children: [
                  if (widget.title != null)
                    Container(
                      alignment: AlignmentDirectional.centerStart,
                      padding: const EdgeInsets.all(24),
                      child: DefaultTextStyle(
                        style: context.textTheme.titleMedium!.copyWith(
                          color: ColorsManager.blackColor,
                          fontSize: 20,
                        ),
                        child: widget.title!,
                      ),
                    ),
                  if (widget.isSide == true)
                    Container(
                      decoration: const BoxDecoration(
                        color: ColorsManager.circleRolesBackground,
                        borderRadius: BorderRadius.only(
                          topRight: Radius.circular(20),
                          topLeft: Radius.circular(20),
                        ),
                      ),
                      child: Padding(
                        padding: const EdgeInsets.all(8.0),
                        child: Row(
                          children: [
                            Expanded(
                              child: Container(
                                decoration: BoxDecoration(
                                  borderRadius: const BorderRadius.all(
                                    Radius.circular(20),
                                  ),
                                  border: Border.all(
                                    color: ColorsManager.grayBorder,
                                  ),
                                ),
                                child: TextFormField(
                                  style: context.textTheme.bodyMedium?.copyWith(
                                    color: ColorsManager.blackColor,
                                  ),
                                  onChanged: (value) =>
                                      context.read<SpaceTreeBloc>().add(
                                            SearchQueryEvent(value),
                                          ),
                                  decoration:
                                      textBoxDecoration(radios: 20)?.copyWith(
                                    fillColor: Colors.white,
                                    suffixIcon: Padding(
                                      padding: const EdgeInsets.only(right: 16),
                                      child: SvgPicture.asset(
                                        Assets.textFieldSearch,
                                        width: 24,
                                        height: 24,
                                      ),
                                    ),
                                    hintStyle:
                                        context.textTheme.bodyMedium?.copyWith(
                                      fontWeight: FontWeight.w400,
                                      fontSize: 12,
                                      color: ColorsManager.textGray,
                                    ),
                                  ),
                                ),
                              ),
                            ),
                          ],
                        ),
                      ),
                    )
                  else
                    CustomSearchBar(
                      onSearchChanged: (query) =>
                          context.read<SpaceTreeBloc>().add(
                                SearchQueryEvent(query),
                              ),
                    ),
                  const SizedBox(height: 16),
                  Expanded(
                    child: state.isSearching
                        ? const Center(child: CircularProgressIndicator())
                        : communities.isEmpty
                            ? Center(
                                child: Text(
                                  'No communities found',
                                  style: context.textTheme.bodyMedium?.copyWith(
                                    color: ColorsManager.textGray,
                                  ),
                                ),
                              )
                            : SidebarCommunitiesList(
                                onScrollToEnd: () {
                                  if (!state.paginationIsLoading) {
                                    context.read<SpaceTreeBloc>().add(
                                          PaginationEvent(
                                            state.paginationModel,
                                            state.communityList,
                                          ),
                                        );
                                  }
                                },
                                scrollController: _scrollController,
                                communities: communities,
                                itemBuilder: (context, index) {
                                  return CustomExpansionTileSpaceTree(
                                    title: communities[index].name,
                                    isSelected: state.selectedCommunities
                                        .contains(communities[index].uuid),
                                    isSoldCheck: state.selectedCommunities
                                        .contains(communities[index].uuid),
                                    onExpansionChanged: () =>
                                        context.read<SpaceTreeBloc>().add(
                                              OnCommunityExpanded(
                                                communities[index].uuid,
                                              ),
                                            ),
                                    isExpanded:
                                        state.expandedCommunities.contains(
                                      communities[index].uuid,
                                    ),
                                    onItemSelected: () {
                                      widget.onSelect();
                                      context.read<SpaceTreeBloc>().add(
                                            OnCommunitySelected(
                                              communities[index].uuid,
                                              communities[index].spaces,
                                            ),
                                          );
                                    },
                                    children: communities[index].spaces.map(
                                      (space) {
                                        return CustomExpansionTileSpaceTree(
                                          title: space.name,
                                          isExpanded: state.expandedSpaces
                                              .contains(space.uuid),
                                          onItemSelected: () {
                                            final isParentSelected =
                                                _isParentSelected(
                                              state,
                                              communities[index],
                                              space,
                                            );
                                            if (widget
                                                    .shouldDisableDeselectingChildrenOfSelectedParent &&
                                                isParentSelected) {
                                              return;
                                            }
                                            widget.onSelect();
                                            context.read<SpaceTreeBloc>().add(
                                                  OnSpaceSelected(
                                                    communities[index],
                                                    space.uuid ?? '',
                                                    space.children,
                                                  ),
                                                );
                                          },
                                          onExpansionChanged: () =>
                                              context.read<SpaceTreeBloc>().add(
                                                    OnSpaceExpanded(
                                                      communities[index].uuid,
                                                      space.uuid ?? '',
                                                    ),
                                                  ),
                                          isSelected: state.selectedSpaces
                                                  .contains(space.uuid) ||
                                              state.soldCheck
                                                  .contains(space.uuid),
                                          isSoldCheck: state.soldCheck
                                              .contains(space.uuid),
                                          children: _buildNestedSpaces(
                                            context,
                                            state,
                                            space,
                                            communities[index],
                                          ),
                                        );
                                      },
                                    ).toList(),
                                  );
                                },
                              ),
                  ),
                  if (state.paginationIsLoading)
                    const CircularProgressIndicator(),
                ],
              ),
      );
    });
  }

  bool _isParentSelected(
      SpaceTreeState state, CommunityModel community, SpaceModel space) {
    return state.selectedCommunities.contains(community.uuid) ||
        (space.spaceModel?.uuid != null &&
            state.selectedSpaces.contains(space.spaceModel?.uuid));
  }

  List<Widget> _buildNestedSpaces(
    BuildContext context,
    SpaceTreeState state,
    SpaceModel space,
    CommunityModel community,
  ) {
    return space.children.map((child) {
      return CustomExpansionTileSpaceTree(
        isSelected: state.selectedSpaces.contains(child.uuid) ||
            state.soldCheck.contains(child.uuid),
        isSoldCheck: state.soldCheck.contains(child.uuid),
        title: child.name,
        isExpanded: state.expandedSpaces.contains(child.uuid),
        onItemSelected: () {
          context.read<SpaceTreeBloc>().add(
                OnSpaceSelected(community, child.uuid ?? '', child.children),
              );
          widget.onSelect();
        },
        onExpansionChanged: () {
          context.read<SpaceTreeBloc>().add(
                OnSpaceExpanded(community.uuid, child.uuid ?? ''),
              );
        },
        children: _buildNestedSpaces(context, state, child, community),
      );
    }).toList();
  }
}
