using Android.Content;
using Android.Views;
using AndroidX.AppCompat.App;
using AndroidX.RecyclerView.Widget;
using Google.Android.Material.FloatingActionButton;
using Google.Android.Material.ProgressIndicator;
using NotesApp.Adapters;
using NotesApp.Graph;
using NotesApp.Models;
using NotesApp.Storage;
using NotesApp.Views;
using Toolbar = AndroidX.AppCompat.Widget.Toolbar;

namespace NotesApp.Activities;

[Activity(Label = "@string/app_name", Exported = false)]
public class NoteListActivity : AppCompatActivity
{
    private const int EditNoteRequestCode = 300;

    private RecyclerView _recyclerView = null!;
    private LinearProgressIndicator _progressBar = null!;
    private NoteListAdapter _adapter = null!;
    private GraphService _graphService = null!;
    private bool _hasScrolledToBottom;

    protected override void OnCreate(Bundle? savedInstanceState)
    {
        AndroidX.Activity.EdgeToEdge.Enable(this);
        base.OnCreate(savedInstanceState);
        SetContentView(Resource.Layout.activity_note_list);

        EdgeToEdgeHelper.Apply(FindViewById(Resource.Id.note_list_root)!);

        SetSupportActionBar(FindViewById<Toolbar>(Resource.Id.note_list_toolbar));

        _recyclerView = FindViewById<RecyclerView>(Resource.Id.note_recycler_view)!;
        _recyclerView.SetLayoutManager(new LinearLayoutManager(this));

        _adapter = new NoteListAdapter(OnNoteTapped);
        _recyclerView.SetAdapter(_adapter);

        _progressBar = FindViewById<LinearProgressIndicator>(Resource.Id.note_refresh_progress)!;

        FindViewById<FloatingActionButton>(Resource.Id.new_note_fab)!.Click += (_, _) =>
            OnNewNoteClicked();

        _graphService = new GraphService(this);

        // Cache renders immediately, scrolled to the bottom, before any network call.
        BindItems(NoteCacheStore.Load());

        _ = RefreshAsync();
    }

    private async Task RefreshAsync()
    {
        var folderId = AppSettings.RootFolderId;
        if (folderId is null)
            return;

        _progressBar.Visibility = ViewStates.Visible;
        try
        {
            var cacheById = NoteCacheStore.Load().ToDictionary(e => e.Id);

            var remoteNotes = await _graphService.ListMarkdownFilesAsync(folderId);

            var changedIds = remoteNotes
                .Where(n =>
                    !cacheById.TryGetValue(n.Id, out var existing) || existing.ETag != n.ETag
                )
                .Select(n => n.Id)
                .ToList();

            var freshPreviews = await _graphService.GetPreviewsAsync(changedIds);

            var merged = remoteNotes
                .Select(n => new NoteCacheEntry(
                    n.Id,
                    n.Name,
                    n.ETag,
                    n.LastModifiedUtc,
                    freshPreviews.TryGetValue(n.Id, out var preview) ? preview
                        : cacheById.TryGetValue(n.Id, out var existing) ? existing.Preview
                        : "",
                    n.Size
                ))
                .OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase)
                .ToList();

            NoteCacheStore.Save(merged);
            BindItems(merged);
        }
        catch (Exception ex)
        {
            Toast.MakeText(this, ex.Message, ToastLength.Long)?.Show();
        }
        finally
        {
            _progressBar.Visibility = ViewStates.Invisible;
        }
    }

    public override bool OnCreateOptionsMenu(IMenu? menu)
    {
        MenuInflater.Inflate(Resource.Menu.menu_note_list, menu);
        return true;
    }

    public override bool OnOptionsItemSelected(IMenuItem item)
    {
        if (item.ItemId == Resource.Id.action_settings)
        {
            StartActivity(new Intent(this, typeof(SettingsActivity)));
            return true;
        }
        return base.OnOptionsItemSelected(item);
    }

    protected override void OnActivityResult(int requestCode, Result resultCode, Intent? data)
    {
        base.OnActivityResult(requestCode, resultCode, data);

        if (requestCode != EditNoteRequestCode || resultCode != Result.Ok)
            return;

        var updatedEntry = NoteResultIntent.TryGet(data);
        if (updatedEntry is null)
            return;

        var list = NoteCacheStore.Load();
        var wasNew = list.RemoveAll(e => e.Id == updatedEntry.Id) == 0;
        list.Add(updatedEntry);
        var merged = list.OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase).ToList();
        NoteCacheStore.Save(merged);

        _adapter.SetItems(merged);

        // A newly created note that landed at the bottom should be scrolled into view,
        // regardless of the usual "only auto-scroll on first load" guard in BindItems.
        var index = merged.FindIndex(e => e.Id == updatedEntry.Id);
        if (wasNew && index == merged.Count - 1)
            _recyclerView.ScrollToPosition(index);
    }

    private void OnNewNoteClicked()
    {
        var fileName = DateTime.Now.ToString("yyyy-MM-ddTHHmmss") + ".md";
        var intent = new Intent(this, typeof(NoteViewActivity));
        intent.PutExtra(NoteViewActivity.ExtraNoteName, fileName);
        StartActivityForResult(intent, EditNoteRequestCode);
    }

    private void OnNoteTapped(NoteCacheEntry entry)
    {
        var intent = new Intent(this, typeof(NoteViewActivity));
        NoteResultIntent.Put(intent, entry);
        StartActivityForResult(intent, EditNoteRequestCode);
    }

    private void BindItems(List<NoteCacheEntry> entries)
    {
        _adapter.SetItems(entries);

        // Only force scroll-to-bottom on the initial (cache-empty) load; don't yank the
        // scroll position if the user is already reading older notes when a refresh lands.
        if (!_hasScrolledToBottom && entries.Count > 0)
        {
            _recyclerView.ScrollToPosition(entries.Count - 1);
            _hasScrolledToBottom = true;
        }
    }
}