import com.officedepot.cms.model.cms2.components.CMSSiteMenuComponentModel
import com.officedepot.cms.model.cms2.components.CMSSiteMenuItemComponentModel
import com.officedepot.multicountrycms.model.CMSSiteRestrictionModel
import de.hybris.platform.basecommerce.model.site.BaseSiteModel
import de.hybris.platform.cms2.model.contents.components.CMSImageComponentModel
import de.hybris.platform.cms2.model.pages.AbstractPageModel
import de.hybris.platform.cms2lib.model.components.AbstractBannerComponentModel
import de.hybris.platform.core.Registry
import de.hybris.platform.core.model.media.MediaModel
import de.hybris.platform.servicelayer.i18n.CommonI18NService
import de.hybris.platform.servicelayer.model.ModelService
import de.hybris.platform.servicelayer.search.FlexibleSearchService
import groovy.transform.Field
import org.apache.commons.collections.CollectionUtils

import java.util.stream.Collectors

@Field def GET_PAGES_QUERY = "SELECT {p.pk}\n" +
        "FROM {AbstractPage AS p\n" +
        "JOIN CatalogVersion AS cv ON {p.catalogVersion} = {cv.pk}\n" +
        "JOIN CmsPageStatus AS ps ON {p.pageStatus} = {ps.pk}}\n" +
        "WHERE {cv.version} = 'Staged' AND {ps.code} = 'active'"

@Field def flexibleSearchService = Registry.getApplicationContext().getBean(FlexibleSearchService.class)
@Field def commonI18NService = Registry.getApplicationContext().getBean(CommonI18NService.class)
@Field def modelService = Registry.getApplicationContext().getBean(ModelService.class)

@Field Locale fallbackLocale = new Locale("en")

@Field def nlLocale = new Locale("nl")
@Field def deDeLocale = new Locale("de", "DE")
@Field def deAtLocale = new Locale("de", "AT")
@Field def deLocale = new Locale("de")

@Field def localesToCheck = [nlLocale, deDeLocale, deAtLocale]
@Field Map<Locale, Locale> localeToAllowedFallback = [:]
localeToAllowedFallback.put(deDeLocale, deLocale)
localeToAllowedFallback.put(deAtLocale, deLocale)


interface PageToSiteClassificationRule
{
  void classify(List<AbstractPageModel> pages, Map<BaseSiteModel, List<AbstractPageModel>> siteToPagesMap)
}

class RestrictionBasedClassificationRule implements PageToSiteClassificationRule
{
  @Override
  void classify(List<AbstractPageModel> pages, Map<BaseSiteModel, List<AbstractPageModel>> siteToPagesMap)
  {
    List<AbstractPageModel> classifiedPages = []
    for (def page : pages)
    {page.approvalStatus
      List<BaseSiteModel> restrictedSites = page.restrictions.stream()
              .filter({ restriction -> CMSSiteRestrictionModel.isInstance(restriction) })
              .map({ restriction -> CMSSiteRestrictionModel.cast(restriction) })
              .flatMap({ siteRestriction -> siteRestriction.baseSites.stream() })
              .collect(Collectors.toList())


      if (CollectionUtils.isNotEmpty(restrictedSites))
      {
        classifiedPages.add(page)
        restrictedSites.forEach({ site ->
          siteToPagesMap.computeIfAbsent(site, { siteModel -> [] })
          siteToPagesMap[site].add(page)
        })
      }
    }
    pages.removeAll(classifiedPages)
  }
}

class PageIdBasedClassificationRule implements PageToSiteClassificationRule
{
  def GET_ALL_SITES_QUERY = "SELECT {pk} FROM {CMSSite}"
  def flexibleSearchService = Registry.getApplicationContext().getBean(FlexibleSearchService.class)
  List<BaseSiteModel> sites = flexibleSearchService.<BaseSiteModel>search(GET_ALL_SITES_QUERY).result as List<BaseSiteModel>

  @Override
  void classify(List<AbstractPageModel> pages, Map<BaseSiteModel, List<AbstractPageModel>> siteToPagesMap)
  {
    List<AbstractPageModel> classifiedPages = []
    for (def page : pages)
    {
      for (def site : sites)
      {
        def isAssigned = false
        if (page.uid.matches("(.*[^a-zA-Z]|)(" + site.uid.toUpperCase() + "|" + site.uid.toLowerCase() + ")([^a-zA-Z].*|)") ||
            page.uid.matches(".*" + site.uid[0].toUpperCase() + site.uid.substring(1).toLowerCase() + "[A-Z].*"))
        {
          if (isAssigned)
          {
            println("WARN! Page " + page.uid + " is not resolvable by uid. Check it manually!")
          }
          classifiedPages.add(page)
          siteToPagesMap.computeIfAbsent(site, { siteModel -> [] })
          siteToPagesMap[site].add(page)
          //noinspection GroovyUnusedAssignment
          isAssigned = true
        }
      }
    }
    pages.removeAll(classifiedPages)
  }
}

@Field List<PageToSiteClassificationRule> pageToSiteFilterRules = [
        new RestrictionBasedClassificationRule(),
        new PageIdBasedClassificationRule()
]

interface ImageHolder
{
  MediaModel getMedia(Locale locale)
  void setMedia(MediaModel media, Locale locale)
}

class CMSImageComponentImageHolder implements ImageHolder
{
  private CMSImageComponentModel imageComponent

  CMSImageComponentImageHolder(CMSImageComponentModel imageComponent)
  {
    this.imageComponent = imageComponent
  }

  @Override
  MediaModel getMedia(Locale locale)
  {
    return imageComponent.getMedia(locale)
  }

  @Override
  void setMedia(MediaModel media, Locale locale)
  {
    imageComponent.setMedia(media, locale)
  }

  @Override
  String toString() {
    return "CMSImageComponent - " + imageComponent.uid + ", property - media"
  }
}

class CMSSiteMenuItemImageHolder implements ImageHolder
{
  private CMSSiteMenuItemComponentModel siteMenuItem

  CMSSiteMenuItemImageHolder(CMSSiteMenuItemComponentModel siteMenuItem)
  {
    this.siteMenuItem = siteMenuItem
  }

  @Override
  MediaModel getMedia(Locale locale)
  {
    return siteMenuItem.getCountryFlag(locale)
  }

  @Override
  void setMedia(MediaModel media, Locale locale)
  {
    siteMenuItem.setCountryFlag(media, locale)
  }

  @Override
  String toString() {
    return "CMSSiteMenuItemComponent - " + siteMenuItem.uid + ", property - countryFlag"
  }
}

class AbstractBannerImageHolder implements ImageHolder
{
  AbstractBannerComponentModel banner

  AbstractBannerImageHolder(AbstractBannerComponentModel banner)
  {
    this.banner = banner
  }

  @Override
  MediaModel getMedia(Locale locale)
  {
    return banner.getMedia(locale)
  }

  @Override
  void setMedia(MediaModel media, Locale locale)
  {
    banner.setMedia(media, locale)
  }

  @Override
  String toString() {
    return "AbstractBannerComponentModel - " + banner.uid + ", property - media"
  }
}

List<ImageHolder> findAllImagesForPages(List<AbstractPageModel> pages, Locale requiredLocale)
{
  def cmsComponents = pages.stream()

          .flatMap({ page -> //noinspection GrDeprecatedAPIUsage
              page.contentSlots.stream() })
          .map({ slot -> slot.contentSlot })
          .filter({contentSlot -> contentSlot != null})
          .flatMap({ contentSlot -> contentSlot.cmsComponents.stream() })
          .collect(Collectors.toList())

  // CMSImageComponentModel
  List<ImageHolder> imageHolders = cmsComponents.stream()
          .filter({ cmsComponent -> CMSImageComponentModel.isInstance(cmsComponent) })
          .map({ cmsComponent -> CMSImageComponentModel.cast(cmsComponent) })
          .map({ cmsImageComponent -> new CMSImageComponentImageHolder(cmsImageComponent) })
          .collect(Collectors.toList())

  // CMSSiteMenuComponentModel
  imageHolders.addAll(cmsComponents.stream()
          .filter({ cmsComponent -> CMSSiteMenuComponentModel.isInstance(cmsComponent) })
          .map({ cmsComponent -> CMSSiteMenuComponentModel.cast(cmsComponent) })
          .flatMap({ siteMenuComponent -> siteMenuComponent.items.stream() })
          .map({ siteMenuItem -> new CMSSiteMenuItemImageHolder(siteMenuItem) })
          .collect(Collectors.toList()))

  // AbstractBannerComponentModel
  imageHolders.addAll(cmsComponents.stream()
          .filter({ cmsComponent -> AbstractBannerComponentModel.isInstance(cmsComponent) })
          .map({ cmsComponent -> AbstractBannerComponentModel.cast(cmsComponent) })
          .map({ banner -> new AbstractBannerImageHolder(banner) })
          .collect(Collectors.toList()))

  // filter by locale
  imageHolders = imageHolders.stream()
          .filter({ image -> image.getMedia(requiredLocale) == null })
          .filter({ image -> image.getMedia(fallbackLocale) != null })
          .filter({ image -> localeToAllowedFallback.get(requiredLocale) == null || image.getMedia(localeToAllowedFallback.get(requiredLocale)) == null })
          .collect(Collectors.toList())

  return imageHolders
}

List<AbstractPageModel> pages = new ArrayList<>(flexibleSearchService.<AbstractPageModel> search(GET_PAGES_QUERY).result as Collection<? extends AbstractPageModel>)

Map<BaseSiteModel, List<AbstractPageModel>> siteToPagesMap = [:]
for (def rule : pageToSiteFilterRules)
{
  rule.classify(pages, siteToPagesMap)
}

println("//-------------------------CLASSIFIED CMS COMPONENTS TO UPDATE-----------------------")

siteToPagesMap.forEach({site, sitePages ->
  def requiredLocale = commonI18NService.getLocaleForLanguage(site.defaultLanguage)
  if (!localesToCheck.contains(requiredLocale))
  {
    return
  }

  def imageHolders = findAllImagesForPages(sitePages, requiredLocale)
  Locale targetLocale = localeToAllowedFallback.getOrDefault(requiredLocale, requiredLocale)

  println("\nUpdating image components (site - " + site.uid + ", language - " + site.defaultLanguage.isocode + "):")

  imageHolders.stream()
          .forEach({ imageHolder -> println(imageHolder) })
  imageHolders.stream()
          .forEach({ imageHolder -> imageHolder.setMedia(imageHolder.getMedia(fallbackLocale), targetLocale) })

  modelService.saveAll()

  println("Count: " + imageHolders.size())
})