import 'package:collection/collection.dart';
import 'package:dio/dio.dart';
import 'package:easy_localization/easy_localization.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:image_picker/image_picker.dart';
import 'package:island/models/file.dart';
import 'package:island/models/post.dart';
import 'package:island/pods/config.dart';
import 'package:island/pods/network.dart';
import 'package:island/services/file.dart';
import 'package:island/services/compose_storage_db.dart';
import 'package:island/widgets/alert.dart';
import 'package:pasteboard/pasteboard.dart';
import 'dart:async';
import 'dart:developer';

class ComposeState {
  final ValueNotifier<List<UniversalFile>> attachments;
  final TextEditingController titleController;
  final TextEditingController descriptionController;
  final TextEditingController contentController;
  final ValueNotifier<int> visibility;
  final ValueNotifier<bool> submitting;
  final ValueNotifier<Map<int, double>> attachmentProgress;
  final ValueNotifier<SnPublisher?> currentPublisher;
  final String draftId;
  Timer? _autoSaveTimer;

  ComposeState({
    required this.attachments,
    required this.titleController,
    required this.descriptionController,
    required this.contentController,
    required this.visibility,
    required this.submitting,
    required this.attachmentProgress,
    required this.currentPublisher,
    required this.draftId,
  });

  void startAutoSave(WidgetRef ref, {int postType = 0}) {
    _autoSaveTimer?.cancel();
    _autoSaveTimer = Timer.periodic(const Duration(seconds: 3), (_) {
      ComposeLogic.saveDraftWithoutUpload(ref, this, postType: postType);
    });
  }

  void stopAutoSave() {
    _autoSaveTimer?.cancel();
    _autoSaveTimer = null;
  }
}

class ComposeLogic {
  static ComposeState createState({
    SnPost? originalPost,
    SnPost? forwardedPost,
    SnPost? repliedPost,
    String? draftId,
  }) {
    final id = draftId ?? DateTime.now().millisecondsSinceEpoch.toString();

    return ComposeState(
      attachments: ValueNotifier<List<UniversalFile>>(
        originalPost?.attachments
                .map(
                  (e) => UniversalFile(
                    data: e,
                    type: switch (e.mimeType?.split('/').firstOrNull) {
                      'image' => UniversalFileType.image,
                      'video' => UniversalFileType.video,
                      'audio' => UniversalFileType.audio,
                      _ => UniversalFileType.file,
                    },
                  ),
                )
                .toList() ??
            [],
      ),
      titleController: TextEditingController(text: originalPost?.title),
      descriptionController: TextEditingController(
        text: originalPost?.description,
      ),
      contentController: TextEditingController(
        text:
            originalPost?.content ??
            (forwardedPost != null ? '> ${forwardedPost.content}\n\n' : null),
      ),
      visibility: ValueNotifier<int>(originalPost?.visibility ?? 0),
      submitting: ValueNotifier<bool>(false),
      attachmentProgress: ValueNotifier<Map<int, double>>({}),
      currentPublisher: ValueNotifier<SnPublisher?>(null),
      draftId: id,
    );
  }

  static ComposeState createStateFromDraft(SnPost draft) {
    return ComposeState(
      attachments: ValueNotifier<List<UniversalFile>>(
        draft.attachments.map((e) => UniversalFile.fromAttachment(e)).toList(),
      ),
      titleController: TextEditingController(text: draft.title),
      descriptionController: TextEditingController(text: draft.description),
      contentController: TextEditingController(text: draft.content),
      visibility: ValueNotifier<int>(draft.visibility),
      submitting: ValueNotifier<bool>(false),
      attachmentProgress: ValueNotifier<Map<int, double>>({}),
      currentPublisher: ValueNotifier<SnPublisher?>(null),
      draftId: draft.id,
    );
  }

  static Future<void> saveDraft(WidgetRef ref, ComposeState state, {int postType = 0}) async {
    final hasContent =
        state.titleController.text.trim().isNotEmpty ||
        state.descriptionController.text.trim().isNotEmpty ||
        state.contentController.text.trim().isNotEmpty;
    final hasAttachments = state.attachments.value.isNotEmpty;

    if (!hasContent && !hasAttachments) {
      return; // Don't save empty posts
    }

    try {
      if (state._autoSaveTimer == null) {
        return;
      }

      // Upload any local attachments first
      final baseUrl = ref.watch(serverUrlProvider);
      final token = await getToken(ref.watch(tokenProvider));
      if (token == null) throw ArgumentError('Token is null');

      for (int i = 0; i < state.attachments.value.length; i++) {
        final attachment = state.attachments.value[i];
        if (attachment.data is! SnCloudFile) {
          try {
            final cloudFile =
                await putMediaToCloud(
                  fileData: attachment,
                  atk: token,
                  baseUrl: baseUrl,
                  filename: attachment.data.name ?? (postType == 1 ? 'Article media' : 'Post media'),
                  mimetype:
                      attachment.data.mimeType ??
                      ComposeLogic.getMimeTypeFromFileType(attachment.type),
                ).future;
            if (cloudFile != null) {
              // Update attachments list with cloud file
              final clone = List.of(state.attachments.value);
              clone[i] = UniversalFile(data: cloudFile, type: attachment.type);
              state.attachments.value = clone;
            }
          } catch (err) {
            log('[ComposeLogic] Failed to upload attachment: $err');
            // Continue with other attachments even if one fails
          }
        }
      }

      final draft = SnPost(
        id: state.draftId,
        title: state.titleController.text,
        description: state.descriptionController.text,
        language: null,
        editedAt: null,
        publishedAt: DateTime.now(),
        visibility: state.visibility.value,
        content: state.contentController.text,
        type: postType,
        meta: null,
        viewsUnique: 0,
        viewsTotal: 0,
        upvotes: 0,
        downvotes: 0,
        repliesCount: 0,
        threadedPostId: null,
        threadedPost: null,
        repliedPostId: null,
        repliedPost: null,
        forwardedPostId: null,
        forwardedPost: null,
        attachments:
            state.attachments.value
                .map((e) => e.data)
                .whereType<SnCloudFile>()
                .toList(),
        publisher: SnPublisher(
          id: '',
          type: 0,
          name: '',
          nick: '',
          picture: null,
          background: null,
          account: null,
          accountId: null,
          createdAt: DateTime.now(),
          updatedAt: DateTime.now(),
          deletedAt: null,
          realmId: null,
          verification: null,
        ),
        reactions: [],
        tags: [],
        categories: [],
        collections: [],
        createdAt: DateTime.now(),
        updatedAt: DateTime.now(),
        deletedAt: null,
      );

      await ref.read(composeStorageNotifierProvider.notifier).saveDraft(draft);
    } catch (e) {
      log('[ComposeLogic] Failed to save draft, error: $e');
    }
  }

  static Future<void> saveDraftWithoutUpload(WidgetRef ref, ComposeState state, {int postType = 0}) async {
    final hasContent =
        state.titleController.text.trim().isNotEmpty ||
        state.descriptionController.text.trim().isNotEmpty ||
        state.contentController.text.trim().isNotEmpty;
    final hasAttachments = state.attachments.value.isNotEmpty;

    if (!hasContent && !hasAttachments) {
      return; // Don't save empty posts
    }

    try {
      if (state._autoSaveTimer == null) {
        return;
      }

      final draft = SnPost(
        id: state.draftId,
        title: state.titleController.text,
        description: state.descriptionController.text,
        language: null,
        editedAt: null,
        publishedAt: DateTime.now(),
        visibility: state.visibility.value,
        content: state.contentController.text,
        type: postType,
        meta: null,
        viewsUnique: 0,
        viewsTotal: 0,
        upvotes: 0,
        downvotes: 0,
        repliesCount: 0,
        threadedPostId: null,
        threadedPost: null,
        repliedPostId: null,
        repliedPost: null,
        forwardedPostId: null,
        forwardedPost: null,
        attachments:
            state.attachments.value
                .map((e) => e.data)
                .whereType<SnCloudFile>()
                .toList(),
        publisher: SnPublisher(
          id: '',
          type: 0,
          name: '',
          nick: '',
          picture: null,
          background: null,
          account: null,
          accountId: null,
          createdAt: DateTime.now(),
          updatedAt: DateTime.now(),
          deletedAt: null,
          realmId: null,
          verification: null,
        ),
        reactions: [],
        tags: [],
        categories: [],
        collections: [],
        createdAt: DateTime.now(),
        updatedAt: DateTime.now(),
        deletedAt: null,
      );

      await ref.read(composeStorageNotifierProvider.notifier).saveDraft(draft);
    } catch (e) {
      log('[ComposeLogic] Failed to save draft without upload, error: $e');
    }
  }

  static Future<void> saveDraftManually(
    WidgetRef ref,
    ComposeState state,
    BuildContext context,
  ) async {
    try {
      final draft = SnPost(
        id: state.draftId,
        title: state.titleController.text,
        description: state.descriptionController.text,
        language: null,
        editedAt: null,
        publishedAt: DateTime.now(),
        visibility: state.visibility.value,
        content: state.contentController.text,
        type: 0,
        meta: null,
        viewsUnique: 0,
        viewsTotal: 0,
        upvotes: 0,
        downvotes: 0,
        repliesCount: 0,
        threadedPostId: null,
        threadedPost: null,
        repliedPostId: null,
        repliedPost: null,
        forwardedPostId: null,
        forwardedPost: null,
        attachments: [], // TODO: Handle attachments
        publisher: SnPublisher(
          id: '',
          type: 0,
          name: '',
          nick: '',
          picture: null,
          background: null,
          account: null,
          accountId: null,
          createdAt: DateTime.now(),
          updatedAt: DateTime.now(),
          deletedAt: null,
          realmId: null,
          verification: null,
        ),
        reactions: [],
        tags: [],
        categories: [],
        collections: [],
        createdAt: DateTime.now(),
        updatedAt: DateTime.now(),
        deletedAt: null,
      );

      await ref.read(composeStorageNotifierProvider.notifier).saveDraft(draft);

      if (context.mounted) {
        showSnackBar(context, 'draftSaved'.tr());
      }
    } catch (e) {
      log('[ComposeLogic] Failed to save draft manually, error: $e');
      if (context.mounted) {
        showSnackBar(context, 'draftSaveFailed'.tr());
      }
    }
  }

  static Future<void> deleteDraft(WidgetRef ref, String draftId) async {
    try {
      await ref
          .read(composeStorageNotifierProvider.notifier)
          .deleteDraft(draftId);
    } catch (e) {
      // Silently fail
    }
  }

  static Future<SnPost?> loadDraft(WidgetRef ref, String draftId) async {
    try {
      return ref
          .read(composeStorageNotifierProvider.notifier)
          .getDraft(draftId);
    } catch (e) {
      return null;
    }
  }

  static String getMimeTypeFromFileType(UniversalFileType type) {
    return switch (type) {
      UniversalFileType.image => 'image/unknown',
      UniversalFileType.video => 'video/unknown',
      UniversalFileType.audio => 'audio/unknown',
      UniversalFileType.file => 'application/octet-stream',
    };
  }

  static Future<void> pickPhotoMedia(WidgetRef ref, ComposeState state) async {
    final result = await ref
        .watch(imagePickerProvider)
        .pickMultiImage(requestFullMetadata: true);
    if (result.isEmpty) return;
    state.attachments.value = [
      ...state.attachments.value,
      ...result.map(
        (e) => UniversalFile(data: e, type: UniversalFileType.image),
      ),
    ];
  }

  static Future<void> pickVideoMedia(WidgetRef ref, ComposeState state) async {
    final result = await ref
        .watch(imagePickerProvider)
        .pickVideo(source: ImageSource.gallery);
    if (result == null) return;
    state.attachments.value = [
      ...state.attachments.value,
      UniversalFile(data: result, type: UniversalFileType.video),
    ];
  }

  static Future<void> uploadAttachment(
    WidgetRef ref,
    ComposeState state,
    int index,
  ) async {
    final attachment = state.attachments.value[index];
    if (attachment.isOnCloud) return;

    final baseUrl = ref.watch(serverUrlProvider);
    final token = await getToken(ref.watch(tokenProvider));
    if (token == null) throw ArgumentError('Token is null');

    try {
      // Update progress state
      state.attachmentProgress.value = {
        ...state.attachmentProgress.value,
        index: 0,
      };

      // Upload file to cloud
      final cloudFile =
          await putMediaToCloud(
            fileData: attachment,
            atk: token,
            baseUrl: baseUrl,
            filename: attachment.data.name ?? 'Post media',
            mimetype:
                attachment.data.mimeType ??
                getMimeTypeFromFileType(attachment.type),
            onProgress: (progress, _) {
              state.attachmentProgress.value = {
                ...state.attachmentProgress.value,
                index: progress,
              };
            },
          ).future;

      if (cloudFile == null) {
        throw ArgumentError('Failed to upload the file...');
      }

      // Update attachments list with cloud file
      final clone = List.of(state.attachments.value);
      clone[index] = UniversalFile(data: cloudFile, type: attachment.type);
      state.attachments.value = clone;
    } catch (err) {
      showErrorAlert(err);
    } finally {
      // Clean up progress state
      state.attachmentProgress.value = {...state.attachmentProgress.value}
        ..remove(index);
    }
  }

  static List<UniversalFile> moveAttachment(
    List<UniversalFile> attachments,
    int idx,
    int delta,
  ) {
    if (idx + delta < 0 || idx + delta >= attachments.length) {
      return attachments;
    }
    final clone = List.of(attachments);
    clone.insert(idx + delta, clone.removeAt(idx));
    return clone;
  }

  static Future<void> deleteAttachment(
    WidgetRef ref,
    ComposeState state,
    int index,
  ) async {
    final attachment = state.attachments.value[index];
    if (attachment.isOnCloud) {
      final client = ref.watch(apiClientProvider);
      await client.delete('/files/${attachment.data.id}');
    }
    final clone = List.of(state.attachments.value);
    clone.removeAt(index);
    state.attachments.value = clone;
  }

  static Future<void> performAction(
    WidgetRef ref,
    ComposeState state,
    BuildContext context, {
    SnPost? originalPost,
    SnPost? repliedPost,
    SnPost? forwardedPost,
    int? postType, // 0 for regular post, 1 for article
  }) async {
    if (state.submitting.value) return;

    // Don't submit empty posts (no content and no attachments)
    final hasContent =
        state.titleController.text.trim().isNotEmpty ||
        state.descriptionController.text.trim().isNotEmpty ||
        state.contentController.text.trim().isNotEmpty;
    final hasAttachments = state.attachments.value.isNotEmpty;

    if (!hasContent && !hasAttachments) {
      if (context.mounted) {
        showSnackBar(context, 'postContentEmpty'.tr());
      }
      return; // Don't submit empty posts
    }

    try {
      state.submitting.value = true;

      // Upload any local attachments first
      await Future.wait(
        state.attachments.value
            .asMap()
            .entries
            .where((entry) => entry.value.isOnDevice)
            .map((entry) => uploadAttachment(ref, state, entry.key)),
      );

      // Prepare API request
      final client = ref.watch(apiClientProvider);
      final isNewPost = originalPost == null;
      final endpoint = isNewPost ? '/posts' : '/posts/${originalPost.id}';

      // Create request payload
      final payload = {
        'title': state.titleController.text,
        'description': state.descriptionController.text,
        'content': state.contentController.text,
        'visibility': state.visibility.value,
        'attachments':
            state.attachments.value
                .where((e) => e.isOnCloud)
                .map((e) => e.data.id)
                .toList(),
        if (postType != null) 'type': postType,
        if (repliedPost != null) 'replied_post_id': repliedPost.id,
        if (forwardedPost != null) 'forwarded_post_id': forwardedPost.id,
      };

      // Send request
      await client.request(
        endpoint,
        data: payload,
        options: Options(
          headers: {'X-Pub': state.currentPublisher.value?.name},
          method: isNewPost ? 'POST' : 'PATCH',
        ),
      );

      // Delete draft after successful submission
      if (postType == 1) {
        // Delete article draft
        await ref
            .read(composeStorageNotifierProvider.notifier)
            .deleteDraft(state.draftId);
      } else {
        // Delete regular post draft
        await ref
            .read(composeStorageNotifierProvider.notifier)
            .deleteDraft(state.draftId);
      }

      if (context.mounted) {
        Navigator.of(context).maybePop(true);
      }
    } catch (err) {
      showErrorAlert(err);
    } finally {
      state.submitting.value = false;
    }
  }

  static Future<void> handlePaste(ComposeState state) async {
    final clipboard = await Pasteboard.image;
    if (clipboard == null) return;

    state.attachments.value = [
      ...state.attachments.value,
      UniversalFile(
        data: XFile.fromData(clipboard, mimeType: "image/jpeg"),
        type: UniversalFileType.image,
      ),
    ];
  }

  static void handleKeyPress(
    RawKeyEvent event,
    ComposeState state,
    WidgetRef ref,
    BuildContext context, {
    SnPost? originalPost,
    SnPost? repliedPost,
    SnPost? forwardedPost,
    int? postType,
  }) {
    if (event is! RawKeyDownEvent) return;

    final isPaste = event.logicalKey == LogicalKeyboardKey.keyV;
    final isSave = event.logicalKey == LogicalKeyboardKey.keyS;
    final isModifierPressed = event.isMetaPressed || event.isControlPressed;
    final isSubmit = event.logicalKey == LogicalKeyboardKey.enter;

    if (isPaste && isModifierPressed) {
      handlePaste(state);
    } else if (isSave && isModifierPressed) {
      saveDraftManually(ref, state, context);
    } else if (isSubmit && isModifierPressed && !state.submitting.value) {
      performAction(
        ref,
        state,
        context,
        originalPost: originalPost,
        repliedPost: repliedPost,
        forwardedPost: forwardedPost,
        postType: postType,
      );
    }
  }

  static void dispose(ComposeState state) {
    state.stopAutoSave();
    state.titleController.dispose();
    state.descriptionController.dispose();
    state.contentController.dispose();
    state.attachments.dispose();
    state.visibility.dispose();
    state.submitting.dispose();
    state.attachmentProgress.dispose();
    state.currentPublisher.dispose();
  }
}