<?php

/*

 *  $Id$

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information, see

 * <http://www.doctrine-project.org>.

 */

namespace Doctrine\DBAL\Schema;

use Doctrine\DBAL\Types\Type;

use Doctrine\DBAL\Schema\Visitor\Visitor;

use Doctrine\DBAL\DBALException;

/**

 * Object Representation of a table

 *

 * @license http://www.opensource.org/licenses/lgpl-license.php LGPL

 * @link    www.doctrine-project.org

 * @since   2.0

 * @version $Revision$

 * @author  Benjamin Eberlei <kontakt@beberlei.de>

 */

class Table extends AbstractAsset

{

    /**

     * @var string

     */

    protected $_name = null;

    /**

     * @var array

     */

    protected $_columns = array();

    /**

     * @var array

     */

    protected $_indexes = array();

    /**

     * @var string

     */

    protected $_primaryKeyName = false;

    /**

     * @var array

     */

    protected $_fkConstraints = array();

    /**

     * @var array

     */

    protected $_options = array();

    /**

     * @var SchemaConfig

     */

    protected $_schemaConfig = null;

    /**

     *

     * @param string $tableName

     * @param array $columns

     * @param array $indexes

     * @param array $fkConstraints

     * @param int $idGeneratorType

     * @param array $options

     */

    public function __construct($tableName, array $columns=array(), array $indexes=array(), array $fkConstraints=array(), $idGeneratorType = 0, array $options=array())

    {

        if (strlen($tableName) == 0) {

            throw DBALException::invalidTableName($tableName);

        }

        $this->_setName($tableName);

        $this->_idGeneratorType = $idGeneratorType;

        foreach ($columns AS $column) {

            $this->_addColumn($column);

        }

        foreach ($indexes AS $idx) {

            $this->_addIndex($idx);

        }

        foreach ($fkConstraints AS $constraint) {

            $this->_addForeignKeyConstraint($constraint);

        }

        $this->_options = $options;

    }

    /**

     * @param SchemaConfig $schemaConfig

     */

    public function setSchemaConfig(SchemaConfig $schemaConfig)

    {

        $this->_schemaConfig = $schemaConfig;

    }

    /**

     * @return int

     */

    protected function _getMaxIdentifierLength()

    {

        if ($this->_schemaConfig instanceof SchemaConfig) {

            return $this->_schemaConfig->getMaxIdentifierLength();

        } else {

            return 63;

        }

    }

    /**

     * Set Primary Key

     *

     * @param array $columns

     * @param string $indexName

     * @return Table

     */

    public function setPrimaryKey(array $columns, $indexName = false)

    {

        $primaryKey = $this->_createIndex($columns, $indexName ?: "primary", true, true);

        foreach ($columns AS $columnName) {

            $column = $this->getColumn($columnName);

            $column->setNotnull(true);

        }

        return $primaryKey;

    }

    /**

     * @param array $columnNames

     * @param string $indexName

     * @return Table

     */

    public function addIndex(array $columnNames, $indexName = null)

    {

        if($indexName == null) {

            $indexName = $this->_generateIdentifierName(

                array_merge(array($this->getName()), $columnNames), "idx", $this->_getMaxIdentifierLength()

            );

        }

        return $this->_createIndex($columnNames, $indexName, false, false);

    }

    /**

     *

     * @param array $columnNames

     * @param string $indexName

     * @return Table

     */

    public function addUniqueIndex(array $columnNames, $indexName = null)

    {

        if ($indexName == null) {

            $indexName = $this->_generateIdentifierName(

                array_merge(array($this->getName()), $columnNames), "uniq", $this->_getMaxIdentifierLength()

            );

        }

        return $this->_createIndex($columnNames, $indexName, true, false);

    }

    /**

     * Check if an index begins in the order of the given columns.

     *

     * @param  array $columnsNames

     * @return bool

     */

    public function columnsAreIndexed(array $columnsNames)

    {

        foreach ($this->getIndexes() AS $index) {

            /* @var $index Index */

            if ($index->spansColumns($columnsNames)) {

                return true;

            }

        }

        return false;

    }

    /**

     *

     * @param array $columnNames

     * @param string $indexName

     * @param bool $isUnique

     * @param bool $isPrimary

     * @return Table

     */

    private function _createIndex(array $columnNames, $indexName, $isUnique, $isPrimary)

    {

        if (preg_match('(([^a-zA-Z0-9_]+))', $indexName)) {

            throw SchemaException::indexNameInvalid($indexName);

        }

        foreach ($columnNames AS $columnName => $indexColOptions) {

            if (is_numeric($columnName) && is_string($indexColOptions)) {

                $columnName = $indexColOptions;

            }

            if ( ! $this->hasColumn($columnName)) {

                throw SchemaException::columnDoesNotExist($columnName, $this->_name);

            }

        }

        $this->_addIndex(new Index($indexName, $columnNames, $isUnique, $isPrimary));

        return $this;

    }

    /**

     * @param string $columnName

     * @param string $columnType

     * @param array $options

     * @return Column

     */

    public function addColumn($columnName, $typeName, array $options=array())

    {

        $column = new Column($columnName, Type::getType($typeName), $options);

        $this->_addColumn($column);

        return $column;

    }

    /**

     * Rename Column

     *

     * @param string $oldColumnName

     * @param string $newColumnName

     * @return Table

     */

    public function renameColumn($oldColumnName, $newColumnName)

    {

        $column = $this->getColumn($oldColumnName);

        $this->dropColumn($oldColumnName);

        $column->_setName($newColumnName);

        return $this;

    }

    /**

     * Change Column Details

     * 

     * @param string $columnName

     * @param array $options

     * @return Table

     */

    public function changeColumn($columnName, array $options)

    {

        $column = $this->getColumn($columnName);

        $column->setOptions($options);

        return $this;

    }

    /**

     * Drop Column from Table

     * 

     * @param string $columnName

     * @return Table

     */

    public function dropColumn($columnName)

    {

        $columnName = strtolower($columnName);

        $column = $this->getColumn($columnName);

        unset($this->_columns[$columnName]);

        return $this;

    }

    /**

     * Add a foreign key constraint

     *

     * Name is inferred from the local columns

     *

     * @param Table $foreignTable

     * @param array $localColumns

     * @param array $foreignColumns

     * @param array $options

     * @param string $constraintName

     * @return Table

     */

    public function addForeignKeyConstraint($foreignTable, array $localColumnNames, array $foreignColumnNames, array $options=array(), $constraintName = null)

    {

        $constraintName = $constraintName ?: $this->_generateIdentifierName(array_merge((array)$this->getName(), $localColumnNames), "fk", $this->_getMaxIdentifierLength());

        return $this->addNamedForeignKeyConstraint($constraintName, $foreignTable, $localColumnNames, $foreignColumnNames, $options);

    }

    /**

     * Add a foreign key constraint

     *

     * Name is to be generated by the database itsself.

     *

     * @deprecated Use {@link addForeignKeyConstraint}

     * @param Table $foreignTable

     * @param array $localColumns

     * @param array $foreignColumns

     * @param array $options

     * @return Table

     */

    public function addUnnamedForeignKeyConstraint($foreignTable, array $localColumnNames, array $foreignColumnNames, array $options=array())

    {

        return $this->addForeignKeyConstraint($foreignTable, $localColumnNames, $foreignColumnNames, $options);

    }

    /**

     * Add a foreign key constraint with a given name

     *

     * @deprecated Use {@link addForeignKeyConstraint}

     * @param string $name

     * @param Table $foreignTable

     * @param array $localColumns

     * @param array $foreignColumns

     * @param array $options

     * @return Table

     */

    public function addNamedForeignKeyConstraint($name, $foreignTable, array $localColumnNames, array $foreignColumnNames, array $options=array())

    {

        if ($foreignTable instanceof Table) {

            $foreignTableName = $foreignTable->getName();

            foreach ($foreignColumnNames AS $columnName) {

                if ( ! $foreignTable->hasColumn($columnName)) {

                    throw SchemaException::columnDoesNotExist($columnName, $foreignTable->getName());

                }

            }

        } else {

            $foreignTableName = $foreignTable;

        }

        foreach ($localColumnNames AS $columnName) {

            if ( ! $this->hasColumn($columnName)) {

                throw SchemaException::columnDoesNotExist($columnName, $this->_name);

            }

        }

        $constraint = new ForeignKeyConstraint(

            $localColumnNames, $foreignTableName, $foreignColumnNames, $name, $options

        );

        $this->_addForeignKeyConstraint($constraint);

        return $this;

    }

    /**

     * @param string $name

     * @param string $value

     * @return Table

     */

    public function addOption($name, $value)

    {

        $this->_options[$name] = $value;

        return $this;

    }

    /**

     * @param Column $column

     */

    protected function _addColumn(Column $column)

    {

        $columnName = $column->getName();

        $columnName = strtolower($columnName);

        if (isset($this->_columns[$columnName])) {

            throw SchemaException::columnAlreadyExists($this->getName(), $columnName);

        }

        $this->_columns[$columnName] = $column;

    }

    /**

     * Add index to table

     * 

     * @param Index $indexCandidate

     * @return Table

     */

    protected function _addIndex(Index $indexCandidate)

    {

        // check for duplicates

        foreach ($this->_indexes AS $existingIndex) {

            if ($indexCandidate->isFullfilledBy($existingIndex)) {

                return $this;

            }

        }

        $indexName = $indexCandidate->getName();

        $indexName = strtolower($indexName);

        if (isset($this->_indexes[$indexName]) || ($this->_primaryKeyName != false && $indexCandidate->isPrimary())) {

            throw SchemaException::indexAlreadyExists($indexName, $this->_name);

        }

        // remove overruled indexes

        foreach ($this->_indexes AS $idxKey => $existingIndex) {

            if ($indexCandidate->overrules($existingIndex)) {

                unset($this->_indexes[$idxKey]);

            }

        }

        if ($indexCandidate->isPrimary()) {

            $this->_primaryKeyName = $indexName;

        }

        $this->_indexes[$indexName] = $indexCandidate;

        return $this;

    }

    /**

     * @param ForeignKeyConstraint $constraint

     */

    protected function _addForeignKeyConstraint(ForeignKeyConstraint $constraint)

    {

        $constraint->setLocalTable($this);

        if(strlen($constraint->getName())) {

            $name = $constraint->getName();

        } else {

            $name = $this->_generateIdentifierName(

                array_merge((array)$this->getName(), $constraint->getLocalColumns()), "fk", $this->_getMaxIdentifierLength()

            );

        }

        $name = strtolower($name);

        $this->_fkConstraints[$name] = $constraint;

        // add an explicit index on the foreign key columns. If there is already an index that fullfils this requirements drop the request.

        // In the case of __construct calling this method during hydration from schema-details all the explicitly added indexes

        // lead to duplicates. This creates compuation overhead in this case, however no duplicate indexes are ever added (based on columns).

        $this->addIndex($constraint->getColumns());

    }