using Blahblah.FlowerApp.Controls;
using Blahblah.FlowerApp.Data;
using Blahblah.FlowerApp.Data.Model;
using Microsoft.Extensions.Logging;
using static Blahblah.FlowerApp.Extensions;

namespace Blahblah.FlowerApp;

public partial class HomePage : AppContentPage
{
    static readonly BindableProperty FlowersProperty = CreateProperty<FlowerClientItem[], HomePage>(nameof(Flowers));
    static readonly BindableProperty IsRefreshingProperty = CreateProperty<bool, HomePage>(nameof(IsRefreshing));

    public FlowerClientItem[] Flowers
    {
        get => GetValue<FlowerClientItem[]>(FlowersProperty);
        set => SetValue(FlowersProperty, value);
    }
    public bool IsRefreshing
    {
        get => GetValue<bool>(IsRefreshingProperty);
        set => SetValue(IsRefreshingProperty, value);
    }

    bool logined = false;
    bool loaded = false;
    bool? setup;
    double pageWidth;

    const int margin = 12;
    const int cols = 2;
    double[] ys = null!;
    int yIndex;
    int itemWidth;
    int emptyHeight;

    public HomePage(FlowerDatabase database, ILogger<HomePage> logger)
    {
        Database = database;
        Logger = logger;

        InitializeComponent();

        Task.Run(async () =>
        {
            try
            {
                await Database.Setup();
            }
            catch (Exception ex)
            {
                this.LogError(ex, $"error occurs when setting up database, {ex.Message}");
            }
            finally
            {
                setup = true;
            }
        });
    }

    protected override void OnSizeAllocated(double width, double height)
    {
        base.OnSizeAllocated(width, height);

        if (!logined)
        {
            logined = true;
            Task.Run(async () =>
            {
                while (setup == null)
                {
                    await Task.Delay(100);
                }

                await DoValidationAsync();

                if (!loaded)
                {
                    loaded = true;
                    IsRefreshing = true;
                }
            });
        }

        pageWidth = width - margin * 2;
        if (loaded && Flowers?.Length > 0)
        {
            DoInitSize();
            foreach (var item in Flowers)
            {
                DoResizeItem(item);
            }
        }
    }

    private async Task<bool> DoValidationAsync()
    {
        bool invalid = true;
        var oAuth = Constants.Authorization;
        if (!string.IsNullOrEmpty(oAuth))
        {
            try
            {
                var user = await FetchAsync<UserItem>("api/user/profile");
                if (user != null)
                {
                    invalid = false;
                    AppResources.SetUser(user);
                }
            }
            catch (Exception ex)
            {
                this.LogError(ex, $"token is invalid, token: {oAuth}, {ex.Message}");
            }
        }
        if (invalid)
        {
            var source = new TaskCompletionSource<bool>();
            MainThread.BeginInvokeOnMainThread(() =>
            {
                var login = new LoginPage(Database, Logger);
                var sheet = this.ShowBottomSheet(login);
                login.AfterLogined += (sender, user) =>
                {
                    sheet.CloseBottomSheet();
                    source.TrySetResult(true);
                };
            });
            return await source.Task;
        }
        return true;
    }

    private void DoInitSize()
    {
        ys = new double[cols];
        yIndex = 0;
        itemWidth = (int)(pageWidth / cols) - margin * (cols - 1) / 2;
        emptyHeight = (int)(itemWidth * AppResources.EmptySize.Height / AppResources.EmptySize.Width);
    }

    private void DoResizeItem(FlowerClientItem item)
    {
        int height;
        if (item.Width > 0 && item.Height > 0)
        {
            height = itemWidth * item.Height.Value / item.Width.Value;
        }
        else
        {
            height = emptyHeight;
        }
        height += 36;
        double yMin = double.MaxValue;
        for (var i = 0; i < cols; i++)
        {
            if (ys[i] < yMin)
            {
                yMin = ys[i];
                yIndex = i;
            }
        }
        ys[yIndex] += height + margin;
        item.Bounds = new Rect(
            yIndex,
            yMin,
            itemWidth,
            height);
    }

    private async Task DoRefreshAsync()
    {
        try
        {
            var result = await FetchAsync<FlowerResult>("api/flower/latest?photo=true");
            if (result?.Count > 0)
            {
                await Database.UpdateFlowers(result.Flowers);

                DoInitSize();
                var flowers = result.Flowers.Select(f =>
                {
                    var item = new FlowerClientItem(f);
                    if (f.Photos?.Length > 0 && f.Photos[0] is PhotoItem cover)
                    {
                        item.Cover = new UriImageSource { Uri = new Uri($"{Constants.BaseUrl}/{cover.Url}") };
                    }
                    else
                    {
                        item.Cover = "empty_flower.jpg";
                    }
                    DoResizeItem(item);
                    return item;
                });
                this.LogInformation($"got {result.Count} flowers.");

                Flowers = flowers.ToArray();
            }
            else
            {
                Flowers = Array.Empty<FlowerClientItem>();
                this.LogInformation("no flowers.");
            }
        }
        catch (Exception ex)
        {
            await this.AlertError(L("failedGetFlowers", "Failed to get flowers, please try again."));
            this.LogError(ex, $"error occurs in HomePage, {ex.Message}");
        }
        finally
        {
            IsRefreshing = false;
        }
    }

    private void RefreshView_Refreshing(object sender, EventArgs e)
    {
        Task.Run(DoRefreshAsync);
    }
}

public record FlowerResult
{
    public FlowerItem[] Flowers { get; init; } = null!;

    public int Count { get; init; }
}