import QueryString from 'qs';
import { axiosGet, axiosGetFull } from './actions';
import { apiBlogCategories, apiBlogs, apiBlogtags, apiUrl } from './constants';
import moment from 'moment';
import 'moment/locale/es';

export const getCategories = async (locale = 'es') => {
  try {
    const query = QueryString.stringify(
      {
        locale: locale,
        sort: ['name'],
        pagination: {
          limit: -1
        },
        populate: {
          blogs: {
            fields: ['id']
          }
        }
      },
      {
        encodeValuesOnly: true
      }
    );
    let data = await axiosGet(apiBlogCategories, query);
    data =
      data && Array?.isArray(data)
        ? data?.map((element) => {
            return {
              id: element?.id,
              name: element?.name,
              slug: element?.slug,
              totalBlogs: element?.blogs?.length
            };
          })
        : [];

    return data;
  } catch (error) {
    console.log('error ', error);
    return [];
  }
};
export const getTags = async (locale = 'es') => {
  try {
    const query = QueryString.stringify(
      {
        locale: locale,
        sort: ['name'],
        pagination: {
          limit: -1
        }
      },
      {
        encodeValuesOnly: true
      }
    );
    let data = await axiosGet(apiBlogtags, query);
    data =
      data && Array?.isArray(data)
        ? data?.map((element) => {
            return {
              id: element?.id,
              name: element?.name,
              slug: element?.slug
            };
          })
        : [];

    return data;
  } catch (error) {
    console.log('error ', error);
    return [];
  }
};
const generateMonthlyArchives = (data: any[], locale = 'es') => {
  const monthsSet = new Set<string>();
  data.forEach((item) => {
    const monthYear = moment(item.date).format('YYYY-MM');
    monthsSet.add(monthYear);
  });
  const archives = Array.from(monthsSet)
    .map((monthYear, index) => {
      const formattedMonthYear = moment(monthYear, 'YYYY-MM').locale(locale).format('MMMM YYYY');
      return {
        title: formattedMonthYear,
        value: monthYear
      };
    })
    .sort((a, b) => moment(b.title, 'MMMM YYYY').unix() - moment(a.title, 'MMMM YYYY').unix());

  return archives;
};

export const getArchieves = async (locale = 'es') => {
  try {
    const query = QueryString.stringify(
      {
        locale: locale,
        sort: ['date:asc'],
        pagination: {
          limit: -1
        },
        fields: ['date']
      },
      {
        encodeValuesOnly: true
      }
    );
    let data: any[] = (await axiosGet(apiBlogs, query)) || [];
    const archives = generateMonthlyArchives(data, locale);
    return archives;
  } catch (error) {
    console.log('error ', error);
    return [];
  }
};

export const getHighlightsBlogs = async (props: any) => {
  try {
    const { locale = 'es', category = '', tag = '', archieve = '', search = '' } = props;
    const tagQuery = tag
      ? {
          blogTags: {
            slug: tag
          }
        }
      : {};
    const categoryQuery = category
      ? {
          blogCategory: {
            slug: category
          }
        }
      : {};

    const archieveQuery = archieve
      ? {
          date: {
            $gte: moment(archieve, 'YYYY-MM').startOf('month').format('YYYY-MM-DD'),
            $lte: moment(archieve, 'YYYY-MM').endOf('month').format('YYYY-MM-DD')
          }
        }
      : {};
    const searchQuery = search
      ? {
          title: {
            $contains: search
          }
        }
      : {};
    const query = QueryString.stringify(
      {
        locale: locale,
        sort: ['date:asc'],
        filters: {
          isHighlighted: true,
          ...tagQuery,
          ...categoryQuery,
          ...archieveQuery,
          ...searchQuery
        },
        pagination: {
          limit: -1
        },
        fields: ['title', 'date', 'preview', 'isHighlighted', 'slug'],
        populate: {
          thumbnail: {
            fields: ['url', 'width', 'height']
          },
          blogCategory: {
            fields: ['id', 'name', 'slug']
          }
        }
      },
      {
        encodeValuesOnly: true
      }
    );
    let data: any[] = (await axiosGet(apiBlogs, query)) || [];
    data = data?.map((element) => {
      return {
        ...element,
        date: moment(element?.date).locale(locale).format('DD MMM YYYY').toUpperCase(),
        url: '/blog/' + element?.slug
      };
    });

    return data;
  } catch (error) {
    return [];
  }
};

export const getBlogsPreview = async (props: any) => {
  const {
    locale = 'es',
    category = '',
    tag = '',
    archieve = '',
    search = '',
    totalPerPage = 4,
    currentPage = 1,
    otherQueries = {}
  } = props;
  try {
    const tagQuery = tag
      ? {
          blogTags: {
            slug: tag
          }
        }
      : {};
    const categoryQuery = category
      ? {
          blogCategory: {
            slug: category
          }
        }
      : {};

    const archieveQuery = archieve
      ? {
          date: {
            $gte: moment(archieve, 'YYYY-MM').startOf('month').format('YYYY-MM-DD'),
            $lte: moment(archieve, 'YYYY-MM').endOf('month').format('YYYY-MM-DD')
          }
        }
      : {};
    const searchQuery = search
      ? {
          title: {
            $contains: search
          }
        }
      : {};
    const query = QueryString.stringify(
      {
        locale: locale,
        sort: ['date:asc'],
        filters: {
          isHighlighted: false,
          ...tagQuery,
          ...categoryQuery,
          ...archieveQuery,
          ...searchQuery,
          ...otherQueries
        },
        pagination: {
          pageSize: totalPerPage,
          page: currentPage
        },
        fields: ['title', 'date', 'preview', 'isHighlighted', 'slug'],
        populate: {
          thumbnail: {
            fields: ['url', 'width', 'height']
          },
          blogCategory: {
            fields: ['id', 'name', 'slug']
          }
        }
      },
      {
        encodeValuesOnly: true
      }
    );

    let dataFull: any = (await axiosGetFull(apiBlogs, query)) || [];

    const data = dataFull?.data?.map((element: any) => {
      return {
        ...element,
        image: { ...element?.thumbnail, url: apiUrl + element?.thumbnail?.url },
        date: moment(element?.date).locale(locale).format('DD MMM YYYY').toUpperCase(),
        url: '/blog/' + element?.slug,
        category: {
          ...element?.blogCategory,
          url: '/blog?category=' + element?.blogCategory?.slug
        }
      };
    });

    return { data, pagination: dataFull?.pagination };
  } catch (error) {
    return [];
  }
};

export const getOtherBlogs = async (props: any) => {
  const { locale = 'es', slug = '', projectSlug = '', categorySlug = '', citySlug = '' } = props;

  const projectQs = projectSlug
    ? {
        project: {
          slug: projectSlug
        }
      }
    : {};
  const categoryQs = categorySlug
    ? {
        blogCategory: {
          slug: categorySlug
        }
      }
    : {};
  const cityQs = citySlug
    ? {
        city: {
          slug: citySlug
        }
      }
    : {};
  try {
    const query = QueryString.stringify(
      {
        locale: locale,
        sort: ['date:desc'],
        filters: {
          slug: {
            $ne: slug
          },
          ...projectQs,
          ...categoryQs,
          ...cityQs
        },
        pagination: {
          limit: 3
        },
        fields: ['title', 'date', 'slug'],
        populate: {
          thumbnail: {
            fields: ['url', 'width', 'height']
          },
          banner: {
            fields: ['url', 'width', 'height']
          },
          blogCategory: {
            fields: ['id', 'name', 'slug']
          },
          project: {
            fields: ['id', 'name', 'slug']
          }
        }
      },
      {
        encodeValuesOnly: true
      }
    );

    let data: any = (await axiosGet(apiBlogs, query)) || [];

    data = data?.map((element: any) => {
      return {
        ...element,
        image: { ...element?.thumbnail, url: apiUrl + element?.thumbnail?.url },
        banner: { ...element?.banner, url: apiUrl + element?.banner?.url },
        date: moment(element?.date).locale(locale).format('DD MMM YYYY').toUpperCase(),
        url: '/blog/' + element?.slug,
        category: {
          ...element?.blogCategory,
          url: '/blog?category=' + element?.blogCategory?.slug
        },
        project: element?.project
          ? {
              ...element?.project,
              url: '/developments/' + element?.project?.slug
            }
          : null
      };
    });

    return data;
  } catch (error) {
    return [];
  }
};

export const getBlog = async (props: any) => {
  const { locale = 'es', slug = '' } = props;
  try {
    const query = QueryString.stringify(
      {
        locale: locale,

        filters: {
          slug: {
            $eq: slug
          }
        },
        pagination: {
          limit: 1
        },
        populate: {
          thumbnail: {
            fields: ['url', 'width', 'height']
          },
          banner: {
            fields: ['url', 'width', 'height']
          },
          blogCategory: {
            fields: ['id', 'name', 'slug']
          },
          blogTags: {
            fields: ['id', 'name', 'slug']
          },
          galleryImages: {
            fields: ['url', 'width', 'height']
          },
          localizations: {
            fields: ['slug']
          }
        }
      },
      {
        encodeValuesOnly: true
      }
    );

    let data: any = (await axiosGet(apiBlogs, query)) || [];
    data =
      data && data[0]
        ? {
            ...data[0],
            date: moment(data[0]?.date).locale(locale).format('DD MMM YYYY').toUpperCase(),
            category: {
              ...data[0]?.blogCategory,
              url: '/blog?category=' + data[0]?.blogCategory?.slug
            },
            banner: data[0]?.banner
              ? {
                  ...data[0]?.banner,
                  url: apiUrl + data[0]?.banner?.url
                }
              : null,
            galleryImages:
              data[0]?.galleryImages && Array?.isArray(data[0]?.galleryImages)
                ? data[0]?.galleryImages?.map((image: any) => {
                    return {
                      ...image,
                      url: apiUrl + image?.url
                    };
                  })
                : null
          }
        : null;
    return data;
  } catch (error) {
    return null;
  }
};