import type { Language } from '../../runtime';
import { ApiHelper, toHeaderLanguage } from '../../runtime';
import type { RequestPagination, PaginatedResponse, IRequestVideoFilter, IReportForm, IVideoData, IVideoCard, IPopularTags  } from '../../types';

function getSafeReferrer(): string {
  if (!document.referrer) return '';
  try {
    const url = new URL(document.referrer);
    return url.origin + url.pathname;
  } catch {
    return '';
  }
}

/** Собирает query-строку referer_type/referer_value для запроса видео. Пусто, если referer нет. */
function buildRefererQuery(referer?: { type: string; value: string }): string {
  if (!referer?.value) return '';
  const params = new URLSearchParams({
    referer_type: referer.type,
    referer_value: referer.value,
  });
  return `?${params.toString()}`;
}

/** Сервис для работы с API видеороликов */
/** Сервис для работы с API видеороликов */
export class VideosApiService {
  static async getSearchByNiche(
    pagination: RequestPagination,
    lang: Language,
    phrase: string,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/video-search-by-niche',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          query: phrase,
        }
      },
    useRuntimeConfig(),
    );
  }

  static getSearchByNicheFiltered(phrase: string) {
    return async (
      lang: Language,
      pagination: RequestPagination,
      videosFilter: IRequestVideoFilter,
      order?: string,
      niche = NicheHelper.getSiteDefaultNiche(),
    ): Promise<PaginatedResponse<IVideoCard>> => {
      return await ApiHelper.fetch(
        '/videos/video-search-by-niche',
        {
          method: 'POST',
          headers: {
            'X-Niche': niche,
            'X-Language': toHeaderLanguage(lang),
            'X-Cache-Time': '259200',
            'Content-Type': 'application/json',
          },
          params: {
            ...pagination,
            ...(order ? { order } : {}),
          },
          body: {
            query: phrase,
            filter_request: videosFilter,
          }
        },
      useRuntimeConfig(),
      );
    };
  }
  static async sendVideoAbuse(
    data: IReportForm,
    videoGuid: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ) {
    return await ApiHelper.fetch(
      `/videos/send-video-abuse/${videoGuid}`,
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        body: data
      },
    useRuntimeConfig(),
    );
  }
  static async refererPhrasesById(
    lang: Language,
    id: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<string[]> {
    return await ApiHelper.fetch(
      `/videos/referer-phrases-by-id/${id}`,
      {
        method: 'GET',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
      },
    useRuntimeConfig(),
    );
  }
  static async refererPhrasesByUrl(
    lang: Language,
    id: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<string[]> {
    return await ApiHelper.fetch(
      `/videos/referer-phrases-by-url/${id}`,
      {
        method: 'GET',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
      },
    useRuntimeConfig(),
    );
  }
  static async getRelatedVideosById(
    pagination: RequestPagination,
    lang: Language,
    id: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      `/videos/get-related-videos-by-id/${id}`,
      {
        method: 'GET',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
        },
      },
    useRuntimeConfig(),
    );
  }
  static async getRelatedVideosByUrl(
    pagination: RequestPagination,
    lang: Language,
    url: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      `/videos/get-related-videos-by-url/${url}`,
      {
        method: 'GET',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
        },
      },
    useRuntimeConfig(),
    );
  }

  static async getVideoById(
    lang: Language,
    id: string,
    niche = NicheHelper.getSiteDefaultNiche(),
    headers = {} as HeadersInit,
    referer?: { type: string; value: string },
  ): Promise<IVideoData> {
    return await ApiHelper.fetch(
      `/videos/get-video-by-id/${id}${buildRefererQuery(referer)}`,
      {
        method: 'GET',
        headers: {
          ...headers,
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
      },
    useRuntimeConfig(),
    );
  }

  static async getVideoByUrl(
    lang: Language,
    url: string,
    niche = NicheHelper.getSiteDefaultNiche(),
    headers = {} as HeadersInit,
    referer?: { type: string; value: string },
  ): Promise<IVideoData> {
    return await ApiHelper.fetch(
      `/videos/get-video-by-url/${url}${buildRefererQuery(referer)}`,
      {
        method: 'GET',
        headers: {
          ...headers,
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
      },
    useRuntimeConfig(),
    );
  }

  static async videoLike(
    md: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<IVideoData> {
    return await ApiHelper.fetch(
      `/videos/video-like/${md}`,
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
      },
    useRuntimeConfig(),
    );
  }

  static async videoDislike(
    md: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<IVideoData> {
    return await ApiHelper.fetch(
      `/videos/video-dislike/${md}`,
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
      },
    useRuntimeConfig(),
    );
  }

  static async videoView(
    md: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<IVideoData> {
    return await ApiHelper.fetch(
      `/videos/video-view/${md}`,
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        body: {
          referer: getSafeReferrer(),
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNiche(
    lang: Language,
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
          'X-Country-Code': useState<string>('clientCountryCode').value || '',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: videosFilter,
          max_limit: 0,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNicheAndCategory(
    lang: Language,
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    category: string,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche-and-category',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: videosFilter,
          category: category,
          max_limit: 100,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNicheAndModel(
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    model: string,
    lang: Language,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche-and-model',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: videosFilter,
          model: model,
          max_limit: 100,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNicheAndModelAndTag(
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    model: string,
    tag: string,
    lang: Language,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche-and-model-and-tag',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: videosFilter,
          model: model,
          tag: tag,
          max_limit: 100,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNicheAndModelAndChannel(
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    model: string,
    channel: string,
    lang: Language,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche-and-model-and-channel',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: videosFilter,
          model: model,
          channel: channel,
          max_limit: 100,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNicheAndTag(
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    tag: string,
    lang: Language,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche-and-tag',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: {
              ...videosFilter,
          },
          tag,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async getListByNicheAndChannel(
    pagination: RequestPagination,
    videosFilter: IRequestVideoFilter,
    channel: string,
    lang: Language,
    order: string,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<PaginatedResponse<IVideoCard>> {
    return await ApiHelper.fetch(
      '/videos/list-by-niche-and-channel',
      {
        method: 'POST',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          ...pagination,
          order,
        },
        body: {
          filter_request: videosFilter,
          channel,
          max_limit: 100,
        }
      },
    useRuntimeConfig(),
    );
  }

  static async popularTagsByModelName(
    lang: Language,
    model: string,
    limit = 25,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<IPopularTags[]> {
    return await ApiHelper.fetch(
      '/videos/popular-tags-by-model-name',
      {
        method: 'GET',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          limit,
          model,
        },
      },
    useRuntimeConfig(),
    );
  }

  static async popularTagsByChannelName(
    lang: Language,
    channel: string,
    limit = 25,
    niche = NicheHelper.getSiteDefaultNiche(),
  ): Promise<IPopularTags[]> {
    return await ApiHelper.fetch(
      '/videos/popular-tags-by-channel-name',
      {
        method: 'GET',
        headers: {
          'X-Niche': niche,
          'X-Language': toHeaderLanguage(lang),
          'X-Cache-Time': '259200',
          'Content-Type': 'application/json',
        },
        params: {
          limit,
          channel,
        },
      },
    useRuntimeConfig(),
    );
  }
}