const faBaseUrl = "https://panel.parsmega.com/index.php/wp-json/wp/v2/";
const enBaseUrl = "https://enpanel.parsmega.com/index.php/wp-json/wp/v2/";

function getBaseUrlForLocale(local) {
  return local == "fa" ? faBaseUrl : enBaseUrl;
}

function apiValidator(response) {
  if (!response && !response.data) {
    return {
      isValid: false,
      result: null,
    };
  }
  return {
    isValid: parseInt(response.status) < 300,
    result: response.data || null,
  };
}

function mapArticle(article) {
  return {
    id: article.id,
    slug: article.slug,
    title: article.title.rendered,
    content: article.acf.content,
    image: article.acf.image,
    canonicalAdress: article.acf.canonical_address,
    summary: article.acf.summary,
    seoDescription: article.acf.seo_description,
    link: `/articles/post/${article.slug}`,
    publishDate: article.date_gmt,
    seoJsonLd: article.acf.structured_data || null,
  };
}

function mapCategory(category) {
  return {
    id: category.id,
    slug: category.slug,
    parent: category.parent,
    image: category.acf.banner,
    content: category.acf.content,
    seoDescription: category.acf.seo_description,
    title: category.acf.browser_tab_title,
    seoJsonLd: category.acf.structured_data || null,
    acf: category.acf || null
  };
}

function mapProduct(product) {
  let images = [];
  if (product.acf.gallery_image_1) images.push(product.acf.gallery_image_1);
  if (product.acf.gallery_image_2) images.push(product.acf.gallery_image_2);
  if (product.acf.gallery_image_3) images.push(product.acf.gallery_image_3);
  if (product.acf.gallery_image_4) images.push(product.acf.gallery_image_4);

  let files = [];
  if (product.acf.manual_file1 && product.acf.manual_file1.manual_file_adress) {
    files.push({
      name: product.acf.manual_file1.manual_file_name,
      url: product.acf.manual_file1.manual_file_adress,
    });
  }
  if (product.acf.manual_file2 && product.acf.manual_file2.manual_file_adress) {
    files.push({
      name: product.acf.manual_file2.manual_file_name,
      url: product.acf.manual_file2.manual_file_adress,
    });
  }
  if (product.acf.manual_file3 && product.acf.manual_file3.manual_file_adress) {
    files.push({
      name: product.acf.manual_file3.manual_file_name,
      url: product.acf.manual_file3.manual_file_adress,
    });
  }
  if (product.acf.manual_file4 && product.acf.manual_file4.manual_file_adress) {
    files.push({
      name: product.acf.manual_file4.manual_file_name,
      url: product.acf.manual_file4.manual_file_adress,
    });
  }

  let videos = [];
  if (product.acf.videos_000_video_link_1)
    videos.push(product.acf.videos_000_video_link_1);
  if (product.acf.videos_001_video_link_2)
    videos.push(product.acf.videos_001_video_link_2);
  if (product.acf.videos_002_video_link_3)
    videos.push(product.acf.videos_002_video_link_3);
  if (product.acf.videos_003_video_link_4)
    videos.push(product.acf.videos_003_video_link_4);
  if (product.acf.videos_004_video_link_5)
    videos.push(product.acf.videos_004_video_link_5);
  if (product.acf.videos_005_video_link_6)
    videos.push(product.acf.videos_005_video_link_6);
  if (product.acf.videos_006_video_link_7)
    videos.push(product.acf.videos_006_video_link_7);
  if (product.acf.videos_007_video_link_8)
    videos.push(product.acf.videos_007_video_link_8);
  if (product.acf.videos_008_video_link_9)
    videos.push(product.acf.videos_008_video_link_9);
  if (product.acf.videos_009_video_link_10)
    videos.push(product.acf.videos_009_video_link_10);

  return {
    acf: product.acf,
    categories: product.categories || [],
    id: product.id,
    title: product.title.rendered,
    slug: product.slug,
    summary: product.acf.summary,
    canonicalAdress: product.acf.canonical_address,
    hasGuarantee: product.acf.has_guarantee,
    guaranteeValue: product.acf.guarantee_value,
    images: images,
    files: files,
    price: product.acf.product_price,
    purchaseLink: product.acf.purchase_link,
    seoDescription: product.acf.seo_description,
    sourcePageAddress: product.acf.source_page_address,
    description: product.acf.description,
    videos: videos,
    link: `/products/${product.slug}`,
    seoJsonLd: product.acf.structured_data || null,
    order: {
      homePage: product.acf.home_page_order || 100000,
      productsPage: product.acf.main_category_order || 100000,
      categoryPage: product.acf.products_page_order || 100000,
    },
  };
}

function mapAgent(agent) {
  

  return {
    id: agent.id,
    title: agent.title.rendered,
    description: agent.acf.description,
    phone: agent.acf.phone,
    website: agent.acf.website,
    logo: agent.acf.logo,
  };
}

export function addComment(connector, local, name, email, content, postId) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}/comments?author_name=${name}&author_email=${email}&content=${content}&post=${postId}`;
  return connector.post(url);
}

export async function getBlogSlider(connector, local) {
  const sliderCategory = 8;
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}articles?_embed&categories=${sliderCategory}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (!isValid) return null;
    let articles = result.map(mapArticle);
    return articles.length > 0 ? articles[0] : null;
  } catch (e) {
    return null;
  }
}

export async function getArticle(connector, local, slug) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}articles?_embed&filter[name]=${slug}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (!isValid) return null;
    let articles = result.map(mapArticle);
    return articles.length > 0 ? articles[0] : null;
  } catch (e) {
    return null;
  }
}

export async function getArticles(connector, local, articleCount = 1, page = 1) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}articles?status=publish&per_page=${articleCount}&page=${page}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid) return result.map(mapArticle);
    return [];
  } catch (e) {
    return [];
  }
}

export async function getCategory(connector, local, slug) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}categories?slug=${slug}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (!isValid) return null;
    return result.map(mapCategory)[0];
  } catch (e) {
    return null;
  }
}

export async function getAllCategories(connector, local) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}categories?_embed&page=1&per_page=99&acf_format=standard`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (!isValid) return null;
    return result.map(mapCategory);
  } catch (e) {
    return null;
  }
}

export async function getComments(connector, local, postId) {
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}/comments?per_page=50&post=${postId}`;

  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (!isValid) return [];

    return result.map((comment) => {
      return {
        id: comment.id,
        authorName: comment.author_name,
        parent: comment.parent,
        date: comment.date_gmt,
        content: comment.content.rendered,
      };
    });
  } catch (e) {
    return [];
  }
}

export async function getCustomers(connector, local, customerCount = 1, page = 1) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}customers?status=publish&per_page=${customerCount}&page=${page}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid)
      return result.map((slide) => {
        return {
          id: slide.id,
          name: slide.acf.customer_name,
          link: slide.acf.customer_link,
          logo: slide.acf.customer_logo,
        };
      });
    return [];
  } catch (e) {
    return [];
  }
}

export async function getFooterLinks(connector, local) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}footerlinks?status=publish&per_page=100&page=1`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid)
      return result.map((item) => {
        return {
          id: item.id,
          showName: item.acf.showname,
          order: item.acf.order_in_column,
          column: item.acf.column_number,
          linkUrl: item.acf.link_url,
          isExternal: item.acf.is_external_link == "true",
        };
      });
    return [];
  } catch (e) {
    return [];
  }
}

export async function getProduct(connector, local, slug) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}products?_embed&filter[name]=${slug}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (!isValid) return null;
    return result.map(mapProduct)[0];
  } catch (e) {
    return null;
  }
}

export async function getProducts(connector, local, productCount = 1, page = 1) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}products?status=publish&per_page=${productCount}&page=${page}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid) return result.map(mapProduct);
    return [];
  } catch (e) {
    return [];
  }
}

export async function getProductsByCategoryId(
  connector,
  local,
  categoryId,
  productCount = 100,
  page = 1
) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}products?status=publish&categories=${categoryId}&per_page=${productCount}&page=${page}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid) return result.map(mapProduct);
    return [];
  } catch (e) {
    return [];
  }
}

export async function getSimilarProducts(
  connector,
  local,
  productCount = 4,
  categoryId
) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}products?status=publish&per_page=${productCount}&categories=${categoryId}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid) return result.map(mapProduct);
    return [];
  } catch (e) {
    return [];
  }
}

export async function getSlides(connector, local, slideCount = 1, page = 1) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}slides?status=publish&per_page=${slideCount}&page=${page}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid)
      return result.map((slide) => {
        return {
          id: slide.id,
          title: slide.acf.slide_title,
          description: slide.acf.slide_description,
          link: slide.acf.slide_link,
          image: slide.acf.slide_image,
        };
      });
    return [];
  } catch (e) {
    return [];
  }
}

export async function getAgents(connector, local, agentsCount = 100, page = 1) {
  
  const baseUrl = getBaseUrlForLocale(local);
  const url = `${baseUrl}agent?status=publish&per_page=${agentsCount}&page=${page}`;
  try {
    const apiResult = await connector.get(url);
    const { isValid, result } = apiValidator(apiResult);
    if (isValid) return result.map(mapAgent);
    return [];
  } catch (e) {
    return [];
  }
}