using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace StreamCinemaLib.API;

public class Metadata
{
  private const string UserAgent = "User-Agent: XBMC/19 (Linux 6.1; http://www.xbmc.org)";
  private const string AccessToken = "9ajdu4xyn1ig8nxsodr3";
  private const int MaxPageLimit = 100; // thousand is too much for some search types

  private static readonly Uri ApiRoot = new Uri("https://plugin.sc2.zone/api/");
  private static readonly Uri ApiFilter = new Uri(ApiRoot, "media/filter/v2/");

  /// <summary>
  /// Searches for media using an expression.
  /// </summary>
  /// <param name="expression">Expression like part of title. Can be empty string to list all media.</param>
  /// <param name="order">Result ordering direction.</param>
  /// <param name="sort">Result ordering column.</param>
  /// <param name="type">Allowed result type.</param>
  /// <param name="offset">Item offset.</param>
  /// <param name="limit">Maximum returned items count.</param>
  /// <param name="cancel">Asynchronous cancellation.</param>
  /// <returns>Response.</returns>
  public async static Task<FilterResponse?> SearchAsync(string expression, ItemOrder order = ItemOrder.Descending, FilterSortBy sort = FilterSortBy.Score, ItemType type = ItemType.All, int offset = 0, int limit = 0, CancellationToken cancel = default)
  {
    if (expression == null)
      throw new ArgumentNullException();
    if (limit < 0 || offset < 0)
      throw new ArgumentOutOfRangeException();
    if (limit == 0 || limit > MaxPageLimit)
      limit = MaxPageLimit;

		/*
		bool noSearchTerms = expression.Trim().Length == 0;
		UriBuilder uri = new UriBuilder(new Uri(ApiFilter, noSearchTerms ? "all" : "search"));
    uri.Query = $"?access_token={AccessToken}&value={Uri.EscapeDataString(expression)}&order={ToString(order)}&sort={ToString(sort)}&type={ToString(type)}&from={offset.ToString()}&size={limit.ToString()}";
		*/

		bool noSearchTerms = expression.Trim().Length == 0;
		string filterName;
		string sortS = ToString(sort);
		if (sort == FilterSortBy.Title) {
			filterName = "startsWithSimple";
			sortS = "";
		} else if (noSearchTerms) {
			filterName = "all";
		} else {
			filterName = "search";
		} 

    UriBuilder uri = new UriBuilder(new Uri(ApiFilter, filterName));
		string orderS = order == ItemOrder.Ascending ? "asc" : "desc";
    uri.Query = $"?access_token={AccessToken}&value={Uri.EscapeDataString(expression)}&type={ToString(type)}&from={offset.ToString()}&size={limit.ToString()}"
			+ (sortS.Length != 0 ? $"&order={ToString(order)}&sort={sortS}" : "");

    FilterResponse? result = await Program._http.GetFromJsonAsync<FilterResponse>(uri.Uri, CreateFilterJsonOptions(), cancel);
    if (result != null)
      result = FixFilterResponse(result);
    return result;
  }

  /// <summary>
  /// Search for child media.
  /// </summary>
  /// <param name="parentId">Identifier of the parent media.</param>
  /// <param name="sort">Result ordering column.</param>
  /// <param name="cancel">Asynchronous cancellation.</param>
  /// <returns>Response.</returns>
  public async static Task<FilterResponse?> ChildrenAsync(string parentId, FilterSortBy sort = FilterSortBy.Episode, CancellationToken cancel = default)
  {
    if (parentId == null)
      throw new ArgumentNullException();

    UriBuilder uri = new UriBuilder(new Uri(ApiFilter, "parent"));
    uri.Query = $"?access_token={AccessToken}&value={parentId}&sort={ToString(sort)}&size={MaxPageLimit.ToString()}";

    FilterResponse? result = await Program._http.GetFromJsonAsync<FilterResponse>(uri.Uri, CreateFilterJsonOptions(), cancel);
    if (result != null)
      result = FixFilterResponse(result);
    return result;
  }

  /// <summary>
  /// Gets available streams for the given media.
  /// </summary>
  /// <param name="id">Media identifier.</param>
  /// <param name="cancel">Asynchronous cancellation.</param>
  /// <returns>Available streams for download.</returns>
  public static Task<Stream[]?> StreamsAsync(string id, CancellationToken cancel = default)
  {
    if (id == null)
      throw new ArgumentNullException();

    UriBuilder uri = new UriBuilder(new Uri(ApiRoot, "media/" + id + "/streams"));
    uri.Query = $"?access_token={AccessToken}";

    return Program._http.GetFromJsonAsync<Stream[]>(uri.Uri, CreateFilterJsonOptions(), cancel);
  }

  /// <summary>
  /// Tries to get a thumbnail image from a well-known image sources to speed-up loading.
  /// </summary>
  /// <param name="imageUri">Image url with probably full-sized image.</param>
  /// <param name="suggestWidth">Requested image width that may however get rounded or completely ignored.</param>
  /// <param name="suggestHeight">Requested image height that may however get rounded or completely ignored.</param>
  /// <param name="thumbUri">On success the thumbnail address.</param>
  /// <returns>True if thumbnail url got calculated, false otherwise.</returns>
  public static bool TryGetThumbnail(Uri imageUri, int suggestWidth, int suggestHeight, [NotNullWhen(true)] out Uri? thumbUri)
  {
    if (imageUri == null)
      throw new ArgumentNullException();

    switch (imageUri.Host)
    {
      case "image.tmdb.org":
        const string TmdbOrigPrefix = "/t/p/original/";
        if (imageUri.AbsolutePath.StartsWith(TmdbOrigPrefix))
        {
          UriBuilder ub = new UriBuilder(imageUri);
          ub.Path = "/t/p/w300_and_h450_bestv2/" + ub.Path.Substring(TmdbOrigPrefix.Length);
          thumbUri = ub.Uri;
          return true;
        }
        break;

      case "img.csfd.cz":
        if (imageUri.AbsolutePath.StartsWith("/files/images/film/posters/"))
        {
          // 140px, 280px, 420px
          int w;
          if (suggestWidth < 160)
            w = 140;
          else if (suggestWidth < 320)
            w = 280;
          else
            w = 420;
          UriBuilder ub = new UriBuilder(imageUri);
          ub.Host = "image.pmgstatic.com";
          ub.Path = "/cache/resized/w" + w.ToString(CultureInfo.InvariantCulture) + ub.Path;
          thumbUri = ub.Uri;
          return true;
        }
        break;
    }

    thumbUri = null;
    return false;
  }

  private static FilterResponse FixFilterResponse(FilterResponse res)
  {
    if (res == null)
      throw new ArgumentNullException();

    // Fix image URLs as they may miss the https scheme
    if (res.hits != null && res.hits.hits != null)
      foreach (MediaInfo i in res.hits.hits)
      {
        if (i._source == null)
          continue;

        if (i._source.cast != null)
          foreach (Cast j in i._source.cast)
            j.thumbnail = FixImageUrl(j.thumbnail);

        if (i._source.i18n_info_labels != null)
          foreach (InfoLabelI18n j in i._source.i18n_info_labels) {
            if (j.art != null) {
              j.art.poster = FixImageUrl(j.art.poster);
              j.art.fanart = FixImageUrl(j.art.fanart);
            }
          }
      }

    return res;
  }

  private static string FixImageUrl(string url)
  {
    if (url != null && !url.StartsWith("http")) {
      if (url.StartsWith("//"))
        url = "https:" + url;
      else
        url = "https://" + url;
    }
    return url;
  }

  private static string ToString(ItemOrder value)
  {
    switch (value)
    {
      case ItemOrder.Ascending: return "asc";
      case ItemOrder.Descending: return "desc";
      default: throw new ArgumentOutOfRangeException();
    }
  }

  private static string ToString(FilterSortBy value)
  {
    switch (value)
    {
      case FilterSortBy.Score: return "score";
      case FilterSortBy.Year: return "year";
      case FilterSortBy.Premiered: return "premiered";
      case FilterSortBy.DateAdded: return "dateAdded";
      case FilterSortBy.LastChildrenDateAdded: return "lastChildrenDateAdded";
      case FilterSortBy.LastChildPremiered: return "lastChildPremiered";
      case FilterSortBy.Title: return "title";
      case FilterSortBy.PlayCount: return "playCount";
      case FilterSortBy.LastSeen: return "lastSeen";
      case FilterSortBy.Episode: return "episode";
      case FilterSortBy.News: return "news";
      case FilterSortBy.Popularity: return "popularity";
      case FilterSortBy.Trending: return "trending";
      case FilterSortBy.LangDateAdded: return "langDateAdded";
      case FilterSortBy.Custom: return "custom";
      default: throw new ArgumentOutOfRangeException();
    }
  }

  private static string ToString(ItemType value)
  {
    switch (value)
    {
      case ItemType.TVShow: return "tvshow";
      case ItemType.Concert: return "concert";
      case ItemType.Anime: return "anime";
      case ItemType.Movie: return "movie";
      case ItemType.Season: return "season";
      case ItemType.Episode: return "episode";
      case ItemType.All: return "*";
      default: throw new ArgumentOutOfRangeException();
    }
  }

  private static JsonSerializerOptions CreateFilterJsonOptions()
  {
    JsonSerializerOptions options = new JsonSerializerOptions();
    options.Converters.Add(new CustomDateTimeConverter());
    return options;
  }

  sealed class CustomDateTimeConverter : JsonConverter<DateTime>
  {
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
      return DateTime.Parse(reader.GetString());
    }

    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
      throw new NotSupportedException();
    }
  }
}