import 'package:cached_network_image/cached_network_image.dart';
import 'package:flutter/material.dart';
import 'package:flutter_widget_from_html_core/flutter_widget_from_html_core.dart';
import 'package:logging/logging.dart';
import 'package:provider/provider.dart';
import 'package:url_launcher/url_launcher.dart';

import '../../globals.dart';
import '../../models/attachment_media_type_enum.dart';
import '../../models/connection.dart';
import '../../models/entry_tree_item.dart';
import '../../models/timeline_entry.dart';
import '../../screens/image_viewer_screen.dart';
import '../../services/connections_manager.dart';
import '../../services/timeline_manager.dart';
import '../../utils/dateutils.dart';
import '../../utils/snackbar_builder.dart';
import '../../utils/url_opening_utils.dart';
import '../padding.dart';
import 'interactions_bar_control.dart';
import 'status_header_control.dart';

class StatusControl extends StatefulWidget {
  final EntryTreeItem originalItem;
  final bool showActionBar;

  const StatusControl(
      {super.key, required this.originalItem, required this.showActionBar});

  @override
  State<StatusControl> createState() => _StatusControlState();
}

class _StatusControlState extends State<StatusControl> {
  static final _logger = Logger('$StatusControl');

  var showContent = true;

  EntryTreeItem get item => widget.originalItem;

  TimelineEntry get entry => item.entry;

  bool get isPublic => item.entry.isPublic;

  bool get isPost => item.entry.parentId.isEmpty;

  bool get hasComments => entry.engagementSummary.repliesCount > 0;

  @override
  void initState() {
    showContent = entry.spoilerText.isEmpty;
  }

  @override
  Widget build(BuildContext context) {
    final manager = context.watch<TimelineManager>();
    _logger.finest('Building ${item.entry.toShortString()}');
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Column(
        mainAxisAlignment: MainAxisAlignment.start,
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          StatusHeaderControl(
            entry: entry,
            showActionBar: widget.showActionBar,
          ),
          const VerticalPadding(
            height: 5,
          ),
          buildBody(context),
          const VerticalPadding(
            height: 5,
          ),
          buildMediaBar(context),
          const VerticalPadding(
            height: 5,
          ),
          InteractionsBarControl(
            entry: entry,
            isMine: item.isMine,
          ),
          const VerticalPadding(
            height: 5,
          ),
          if (isPost && hasComments)
            TextButton(
              onPressed: () async => await manager.refreshPost(item.id),
              child: Text('Load Comments'),
            ),
          if (item.totalChildren > 0) buildChildComments(context),
        ],
      ),
    );
  }

  Widget buildHeader(BuildContext context) {
    final author = getIt<ConnectionsManager>()
        .getById(entry.authorId)
        .getValueOrElse(() => Connection());
    return Row(
      mainAxisAlignment: MainAxisAlignment.start,
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        CachedNetworkImage(
          imageUrl: author.avatarUrl.toString(),
          width: 32.0,
        ),
        const HorizontalPadding(),
        Column(
          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              author.name,
              style: Theme.of(context).textTheme.bodyText1,
            ),
            Row(
              children: [
                Text(
                  ElapsedDateUtils.epochSecondsToString(
                      entry.backdatedTimestamp),
                  style: Theme.of(context).textTheme.caption,
                ),
                const HorizontalPadding(),
                Icon(
                  isPublic ? Icons.public : Icons.lock,
                  color: Theme.of(context).hintColor,
                  size: Theme.of(context).textTheme.caption?.fontSize,
                ),
              ],
            ),
            Text(
              item.id,
            ),
          ],
        ),
      ],
    );
  }

  Widget buildBody(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.start,
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        if (entry.spoilerText.isNotEmpty)
          TextButton(
              onPressed: () {
                setState(() {
                  showContent = !showContent;
                });
              },
              child: Text(
                  'Content Summary: ${entry.spoilerText} (Click to ${showContent ? "Hide" : "Show"}}')),
        if (showContent)
          HtmlWidget(
            entry.body,
            onTapUrl: (url) async {
              return await openUrlStringInSystembrowser(context, url, 'video');
            },
            onTapImage: (imageMetadata) {
              print(imageMetadata);
            },
          ),
      ],
    );
  }

  Widget buildMediaBar(BuildContext context) {
    final items = entry.mediaAttachments;
    if (items.isEmpty) {
      return const SizedBox();
    }
    return SizedBox(
        width: 250.0,
        height: 250.0,
        child: ListView.separated(
            scrollDirection: Axis.horizontal,
            itemBuilder: (context, index) {
              final item = items[index];

              if (item.explicitType == AttachmentMediaType.video) {
                return ElevatedButton(
                    onPressed: () async {
                      if (await canLaunchUrl(item.uri)) {
                        buildSnackbar(
                          context,
                          'Attempting to launch video: ${item.uri}',
                        );
                        await launchUrl(item.uri);
                      } else {
                        buildSnackbar(
                            context, 'Unable to launch video: ${item.uri}');
                      }
                    },
                    child: Text(item.description.isNotEmpty
                        ? item.description
                        : 'Video'));
              }
              if (item.explicitType != AttachmentMediaType.image) {
                return Text('${item.explicitType}: ${item.uri}');
              }

              return InkWell(
                onTap: () async {
                  Navigator.push(context, MaterialPageRoute(builder: (context) {
                    return ImageViewerScreen(attachment: item);
                  }));
                },
                child: CachedNetworkImage(
                  width: 250.0,
                  height: 250.0,
                  imageUrl: item.thumbnailUri.toString(),
                ),
              );
              // return Text(item.toString());
            },
            separatorBuilder: (context, index) {
              return HorizontalPadding();
            },
            itemCount: items.length));
  }

  Widget buildChildComments(BuildContext context) {
    final comments = widget.originalItem.children;
    if (comments.isEmpty) {
      return Text('No comments');
    }
    return Padding(
        padding: EdgeInsets.only(left: 20.0, top: 5.0),
        child: Row(
          mainAxisAlignment: MainAxisAlignment.start,
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Icon(Icons.subdirectory_arrow_right),
            Expanded(
              child: Column(
                children: comments
                    .map((c) => StatusControl(
                          originalItem: c,
                          showActionBar: false,
                        ))
                    .toList(),
              ),
            ),
          ],
        ));
  }
}