<?php
/**
 * SOTESHOP/stLanguagePlugin
 *
 * Ten plik należy do aplikacji stLanguagePlugin opartej na licencji (Open License SOTE) Otwarta Licencja SOTE. 
 * Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania. 
 * Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać 
 * oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
 *
 * @package     stLanguagePlugin
 * @subpackage  configs
 * @copyright   SOTE (www.sote.pl)
 * @license     http://www.sote.pl/license/open (Open License SOTE) Otwarta Licencja SOTE
 * @version     $Id: LanguagePeer.php 10732 2011-02-01 12:15:55Z michal $
 * @author      Michal Prochowski <michal.prochowski@sote.pl>
 */

use LanguagePeer as GlobalLanguagePeer;

/**
 * Klasa LanguagePeer
 *
 * @package     stLanguagePlugin
 * @subpackage  libs
 */
class LanguagePeer extends BaseLanguagePeer
{
    /**
     * Dostępne języki w sklepie
     *
     * @var Language[]|null
     */
    protected static $languages = null;
    
    /**
     * Domyślny język panelu administracyjnego
     *
     * @var Language|null
     */
    protected static $defaultBackendLanguage = null;

    /**
     * Zwraca lub tworzy nową instancję wersji językowej
     *
     * @param string $lang Wersja językowa
     * @param string $name Nazwa dla polskiej wersji językowej
     * @param string $name Nazwa dla angielskiej wersji językowej
     * @return Language
     */
    public static function retrieveOrCreate(string $lang, string $nameForPL, string $nameForEN): Language
    {
        $c = new Criteria();
        $c->add(self::LANGUAGE, $lang);
        $language = self::doSelectOne($c);

        if (null === $language)
        {
            $language = new Language();
            $language->setActive(false);
            $language->setSystem(true);
            $language->setIsTranslate(true);
            $language->setActiveImage($lang.'_active.png');
            $language->setInactiveImage($lang.'_inactive.png');
            $language->setLanguage($lang);
            $language->setShortcut($lang);
            $language->setCulture('pl_PL');
            $language->setName($nameForPL);
            $language->setCulture('en_US');
            $language->setName($nameForEN);
        }

        return $language;
    }

    /**
     * Aktualizuje podstawową pamięć podręczną sklepu
     * 
     * @param stSimpleShopDataCache|null $sc 
     * @return stSimpleShopDataCache 
     * @throws sfCacheException 
     */
    public static function doSimpleStoreUpdate(stSimpleShopDataCache $sc = null)
    {
        $languages = array();
        $default = null;

        foreach (self::doSelectActive() as $language)
        {
            $languages[$language->getShortcut()] = stSimpleLanguageHelper::cultureToShortcut($language->getOriginalLanguage());

            if ($language->getIsDefault())
            {
                $default = stSimpleLanguageHelper::cultureToShortcut($language->getOriginalLanguage());
            }
        }

        if (null === $sc)
        {
            $sc = stSimpleShopDataCache::getInstance();
        }
            
        $sc
            ->set('base_language', stSimpleLanguageHelper::cultureToShortcut(stLanguage::getOptLanguage()))
            ->set('default_language', $default)
            ->set('languages', $languages);
        
        return $sc;
    }

    /**
     * Zwraca list dostępnych języków w sklepie
     *
     * @param Criteria|null $criteria
     * @param [type] $con
     * @return Language[]
     */
    public static function doSelectLanguages() 
    {
        $culture = sfContext::getInstance()->getUser()->getCulture();

        if (!isset(self::$languages[$culture]))
        {
            $cache = stFunctionCache::getInstance('stLanguagePlugin');
            self::$languages[$culture] = $cache->cacheCall(['LanguagePeer', 'doSelect'], [new Criteria()], [
                'id' => 'languages_' . $culture
            ]);
        }

        return self::$languages[$culture];
    }

    /**
     * 
     * @param Criteria|null $criteria 
     * @param Connection|null $con 
     * @return Language[] 
     * @throws sfCacheException 
     */
    public static function doSelectActive(Criteria $criteria = null, $con = null)
    {
        $returnLanguages = array();
        $languages = LanguagePeer::doSelectLanguages($criteria, $con);

        foreach ($languages as $language)
        {
            if ($language->getActive())
            {
                $returnLanguages[] = $language;
            }
        }
        return $returnLanguages;
    }

    public static function doSelectDefault(Criteria $criteria = null, $con = null)
    {
        $languages = LanguagePeer::doSelectActive($criteria, $con);

        foreach ($languages as $language)
        {
            if ($language->getIsDefault()) return $language;
        }

        if(isset($languages[0]))
        {
            return $languages[0];
        }

        return null;
    }

    /**
     * Zwraca instajncję wersje językowej
     *
     * @param string $culture Język
     * @param Connection $con
     * @return Language|null
     */
    public static function retrieveByCulture($culture, $con = null)
    {
        $languages = LanguagePeer::doSelectActive(null, $con);

        foreach ($languages as $language)
        {
            if ($language->getOriginalLanguage() == $culture) return $language;
        }

        return null;
    }

    /**
     * Zwraca język po skrócie
     *
     * @param string $culture Język
     * @param Connection $con
     * @return Language|null
     */
    public static function retrieveByShortcut($shortcut, $con = null)
    {
        $languages = LanguagePeer::doSelectActive(null, $con);

        foreach ($languages as $language)
        {
            if ($language->getShortcut() == $shortcut) return $language;
        }

        return null;
    }

    /**
     * Zwraca wersje językową po domenie
     *
     * @param string $domainParam
     * @param Connection $con
     * @return Language|null
     */
    public static function doSelectByDomain($domainParam, $con = null)
    {
        $domains = LanguageHasDomainPeer::doSelectAll($con);
        $languages = LanguagePeer::doSelectLanguages(null, $con);

        $languageId = null;
        foreach($domains as $domain)
        {
            if ($domain->getDomain() == $domainParam)
            {
                $languageId = $domain->getLanguageId();
                break;
            }
        }

        if ($languageId == null) return null;

        foreach($languages as $language)
        {
            if ($language->getId() == $languageId)
            {
                return $language;
            }
        }
    }

    public static function retrieveDefaultBackendLanguage(): Language
    {
        if (null === self::$defaultBackendLanguage)
        {
            $languages = LanguagePeer::doSelectLanguages();

            foreach ($languages as $language)
            {
                if ($language->getIsDefaultPanel())
                {
                    self::$defaultBackendLanguage = $language;
                    break;
                }
            }
        }

        return self::$defaultBackendLanguage;
    }
    
    public static function doSelectWithI18n(Criteria $c, $culture = null, $con = null)
    {
        if ($culture === null)
        {
            $culture = stLanguage::getHydrateCulture();
        }

        if ($c->getDbName() == Propel::getDefaultDB())
        {
            $c->setDbName(self::DATABASE_NAME);
        }

        LanguagePeer::addSelectColumns($c);

        $startcol = (LanguagePeer::NUM_COLUMNS - LanguagePeer::NUM_LAZY_LOAD_COLUMNS) + 1;

        LanguageI18nPeer::addSelectColumns($c);

        $c->addJoin(LanguagePeer::ID, sprintf("%s AND %s = '%s'", LanguageI18nPeer::ID, LanguageI18nPeer::CULTURE, $culture), Criteria::LEFT_JOIN);

        $rs = BasePeer::doSelect($c, $con);

        $results = array();

        while($rs->next())
        {

            $omClass = LanguagePeer::getOMClass();

            $cls = Propel::import($omClass);
            $obj1 = new $cls();
            $obj1->hydrate($rs);
            $obj1->setCulture($culture);

            $omClass = LanguageI18nPeer::getOMClass($rs, $startcol);

            $cls = Propel::import($omClass);
            $obj2 = new $cls();
            $obj2->hydrate($rs, $startcol);

            $obj1->setLanguageI18nForCulture($obj2, $culture);
            $obj2->setLanguage($obj1);

            $results[] = $obj1;
        }
        return $results;
    }

    public static function doClearDefaultBackendLanguage(?int $ignoreId = null)
    {
        $selectCriteria = new Criteria();
        $updateCriteria = new Criteria();

        if (null !== $ignoreId)
        {
            $selectCriteria->add(self::ID, $ignoreId, Criteria::NOT_EQUAL);
        }

        $updateCriteria->add(self::IS_DEFAULT_PANEL, false);

        return BasePeer::doUpdate($selectCriteria, $updateCriteria, Propel::getConnection());
    }
    
    public static function doCountWithI18n(Criteria $c, $con = null)
    {
        $c->addJoin(LanguageI18nPeer::ID, LanguagePeer::ID);

        $c->add(LanguageI18nPeer::CULTURE, stLanguage::getHydrateCulture());

        return self::doCount($c, $con);
    }

    public static function getLanguagesAsArray() {
        $languages = self::doSelectLanguages();
        $list = array();

        foreach ($languages as $language)
            $list[$language->getLanguage()] = $language->getName();

        return $list;
    }
}