1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 442: 443: 444: 445: 446: 447: 448: 449: 450: 451: 452: 453: 454: 455: 456: 457: 458: 459: 460: 461: 462: 463: 464: 465: 

<?php

    namespace Inlm\SchemaGenerator\Extractors;

    use CzProject\SqlSchema;
    use Inlm\SchemaGenerator\DataType;
    use Inlm\SchemaGenerator\IExtractor;
    use Inlm\SchemaGenerator\EmptyException;
    use Inlm\SchemaGenerator\InvalidArgumentException;
    use Inlm\SchemaGenerator\MissingException;
    use Inlm\SchemaGenerator\Utils\Generator;
    use Inlm\SchemaGenerator\Utils\DataTypeParser;
    use Nette;
    use LeanMapper\IMapper;
    use LeanMapper\Reflection;
    use LeanMapper\Reflection\AnnotationsParser;
    use LeanMapper\Relationship;


    class LeanMapperExtractor implements IExtractor
    {
        /** @var IMapper */
        protected $mapper;

        /** @var string|string[] */
        protected $directories;

        /** @var array  [name => DataType] */
        protected $customTypes;


        /**
         * @param  string|string[]
         * @param  IMapper
         */
        public function __construct($directories, IMapper $mapper)
        {
            $this->directories = $directories;
            $this->mapper = $mapper;
        }


        /**
         * @return Schema
         */
        public function generateSchema(array $options = array(), array $customTypes = array())
        {
            $generator = new Generator($options);
            $this->customTypes = $customTypes;
            $entities = $this->findEntities();

            foreach ($entities as $entity) {
                $this->generateEntity($generator, $entity);
            }

            $generator->createHasManyTables();
            $generator->createRelationships();

            return $generator->getSchema();
        }


        protected function generateEntity(Generator $generator, $entityClass)
        {
            $reflection = call_user_func(array($entityClass, 'getReflection'), $this->mapper);
            $properties = $reflection->getEntityProperties();

            if (empty($properties)) {
                return;
            }

            $tableName = $this->mapper->getTable($entityClass);
            $tablePrimaryColumn = $this->mapper->getPrimaryKey($tableName);
            $table = $generator->createTable($tableName, $tablePrimaryColumn);
            $propertySources = array();

            foreach ($this->getFamilyLine($reflection) as $member) {
                $docComment = $member->getDocComment();
                $this->extractTableComment($table, $docComment);
                $this->extractTableOption($table, $docComment);
                $this->extractTableIndexes($generator, $tableName, $member, 'primary');
                $this->extractTableIndexes($generator, $tableName, $member, 'unique');
                $this->extractTableIndexes($generator, $tableName, $member, 'index');

                $memberClass = $member->getName();
                $memberProperties = array_keys($member->getEntityProperties());

                foreach ($memberProperties as $memberProperty) {
                    if (!isset($propertySources[$memberProperty])) {
                        $propertySources[$memberProperty] = $memberClass;
                    }
                }
            }

            // hack - primary column must be always first (@property-read is always last)
            if (isset($properties[$tablePrimaryColumn])) {
                $properties = array($tablePrimaryColumn => $properties[$tablePrimaryColumn]) + $properties;
            }

            foreach ($properties as $property) {
                if ($property->hasRelationship()) {
                    $relationship = $property->getRelationship();

                    if ($relationship instanceof Relationship\HasMany) {
                        $this->addHasManyRelationship($generator, $relationship, $tableName);
                        continue; // virtual column

                    } elseif ($relationship instanceof Relationship\HasOne) {
                        $generator->addRelationship($tableName, $relationship->getColumnReferencingTargetTable(), $relationship->getTargetTable());

                    } elseif ($relationship instanceof Relationship\BelongsTo) {
                        $generator->addRelationship($relationship->getTargetTable(), $relationship->getColumnReferencingSourceTable(), $tableName);
                        continue; // virtual column

                    } else {
                        throw new \RuntimeException('Unknow relationship ' . (is_object($relationship) ? get_class($relationship) : gettype($relationship))); // TODO
                    }
                }

                $propertyName = $property->getName();
                $entitySource = isset($propertySources[$propertyName]) ? $propertySources[$propertyName] : $entityClass;
                $propertySource = $entitySource . '::' . $propertyName;
                $columnName = $property->getColumn();
                $isPrimaryColumn = $generator->isTablePrimaryColumn($tableName, $columnName);
                $columnType = NULL;

                if (!$property->hasRelationship()) {
                    $columnType = $this->extractColumnType($property, $isPrimaryColumn, $entityClass);
                }

                $column = $generator->addColumn($tableName, $columnName, $columnType, $entitySource);
                $column->setNullable($property->isNullable());

                $this->extractColumnComment($column, $property);
                $this->extractColumnAutoIncrement($column, $property, $generator->getTablePrimaryColumn($tableName));
                $this->extractColumnIndex($generator, $property, 'primary', $tableName, $columnName, $propertySource);
                $this->extractColumnIndex($generator, $property, 'unique', $tableName, $columnName, $propertySource);
                $this->extractColumnIndex($generator, $property, 'index', $tableName, $columnName, $propertySource);
            }

            if (!$generator->hasPrimaryIndex($tableName)) {
                $generator->addPrimaryIndex($tableName, $generator->getTablePrimaryColumn($tableName));
            }
        }


        /**
         * @return void
         */
        protected function extractTableComment(SqlSchema\Table $table, $docComment)
        {
            // @schema-comment comment
            // @schemaComment comment
            $annotations = array(
                'schema-comment',
                'schemaComment',
            );

            foreach ($annotations as $annotation) {
                foreach (AnnotationsParser::parseAnnotationValues($annotation, $docComment) as $definition) {
                    $comment = trim($definition);
                    $table->setComment($comment !== '' ? $comment : NULL);
                }
            }
        }


        /**
         * @return void
         */
        protected function extractTableOption(SqlSchema\Table $table, $docComment)
        {
            // @schema-option option value
            // @schemaOption option value
            $annotations = array(
                'schema-option',
                'schemaOption',
            );

            foreach ($annotations as $annotation) {
                foreach (AnnotationsParser::parseAnnotationValues($annotation, $docComment) as $definition) {
                    $definition = trim($definition);

                    if ($definition === '') {
                        throw new EmptyException("Empty definition of '@{$annotation}'.");
                    }

                    $option = $definition;
                    $value = NULL;

                    if (strpos($definition, ' ') !== FALSE) {
                        list($option, $value) = explode(' ', $definition, 2);
                        $option = trim($option);
                        $value = trim($value);
                    }

                    if ($option === '') {
                        throw new MissingException("Missing option name in '@{$annotation}'.");
                    }

                    $table->setOption(strtoupper($option), $value !== '' ? $value : NULL);
                }
            }
        }


        /**
         * @return void
         */
        protected function extractTableIndexes(Generator $generator, $tableName, Reflection\EntityReflection $reflection, $indexType)
        {
            // @schema-<type> property1, property2
            // @schema<Type> property, property2
            $entityClass = $reflection->getName();
            $annotations = array(
                'schema-' . $indexType,
                'schema' . ucfirst($indexType),
            );

            foreach ($annotations as $annotation) {
                foreach (AnnotationsParser::parseAnnotationValues($annotation, $reflection->getDocComment()) as $definition) {
                    $properties = array_map('trim', explode(',', $definition));
                    $columns = array();

                    foreach ($properties as $property) {
                        $columns[] = $this->mapper->getColumn($property);
                    }

                    $this->addIndexByType($generator, $type, $tableName, $columns, $entityClass);
                }
            }
        }


        /**
         * @return DataType
         */
        protected function extractColumnType(Reflection\Property $property, $isPrimaryColumn, $entityClass)
        {
            $type = NULL;
            $parameters = NULL;
            $options = array();

            if ($property->hasCustomFlag('schema-type')) {
                $datatype = $this->parseTypeFlag($property, 'schema-type');
                $type = $datatype->getType();
                $parameters = $datatype->getParameters();
                $options = $datatype->getOptions();

            } elseif ($property->hasCustomFlag('schemaType')) {
                $datatype = $this->parseTypeFlag($property, 'schemaType');
                $type = $datatype->getType();
                $parameters = $datatype->getParameters();
                $options = $datatype->getOptions();

            } elseif ($property->isBasicType()) {
                $propertyType = $property->getType();

                if ($propertyType === 'integer') {
                    $type = 'INT';

                    if ($isPrimaryColumn) {
                        $options[] = SqlSchema\Column::OPTION_UNSIGNED;
                    }

                } elseif ($propertyType === 'boolean') {
                    $type = 'TINYINT';
                    $parameters = array(1);
                    $options[] = 'UNSIGNED';

                } elseif ($propertyType === 'float') {
                    $type = 'DOUBLE';

                } elseif ($propertyType === 'string') {
                    $type = 'TEXT';
                }

            } else { // object
                $className = $property->getType();
                $isDateTime = is_a($className, 'DateTime', TRUE)
                    || is_a($className, 'DateTimeInterface', TRUE);

                if ($isDateTime) {
                    $type = 'DATETIME';
                }
            }

            if ($type === NULL) {
                throw new MissingException("Missing type for property '{$property->getName()}' in entity '{$entityClass}'.");
            }

            $lowerType = strtolower($type);

            if (isset($this->customTypes[$lowerType])) {
                $columnType = $this->customTypes[$lowerType];
                $type = $columnType->getType();
                $parameters = $columnType->getParameters();
                $options = array_merge($options, $columnType->getOptions());

            }

            return new DataType($type, $parameters, $options);
        }


        /**
         * @param  Reflection\Property
         * @param  string
         * @return DataType
         * @throws InvalidArgumentException
         */
        protected function parseTypeFlag(Reflection\Property $property, $flagName)
        {
            $s = $property->getCustomFlagValue($flagName);
            try {
                return DataTypeParser::parse($s, DataTypeParser::SYNTAX_ALTERNATIVE);

            } catch (\Exception $e) { // TODO
                throw new InvalidArgumentException("Malformed m:{$flagName} definition for property '{$property->getName()}' in entity ''.");
            }
        }


        /**
         * @return void
         */
        protected function extractColumnComment(SqlSchema\Column $column, Reflection\Property $property)
        {
            if ($property->hasCustomFlag('schema-comment')) {
                $column->setComment($property->getCustomFlagValue('schema-comment'));

            } elseif ($property->hasCustomFlag('schemaComment')) {
                $column->setComment($property->getCustomFlagValue('schemaComment'));
            }
        }


        /**
         * @return void
         */
        protected function extractColumnAutoIncrement(SqlSchema\Column $column, Reflection\Property $property, $primaryKey)
        {
            if ($property->hasCustomFlag('schema-autoIncrement') || $property->hasCustomFlag('schemaAutoIncrement')) {
                $column->setAutoIncrement(TRUE);

            } else { // auto-detect
                $column->setAutoIncrement($primaryKey === $column->getName() && $property->getType() === 'integer');
            }
        }


        /**
         * @return void
         */
        protected function extractColumnIndex(Generator $generator, Reflection\Property $property, $type, $tableName, $columnName, $propertySource)
        {
            $flags = array(
                'schema-' . $type,
                'schema' . ucfirst($type),
            );

            foreach ($flags as $flag) {
                if ($property->hasCustomFlag($flag)) {
                    $this->addIndexByType($generator, $type, $tableName, $columnName, $propertySource);
                    return;
                }
            }
        }


        protected function addIndexByType(Generator $generator, $indexType, $tableName, $columns, $sourceId)
        {
            if ($indexType === 'index') {
                $generator->addIndex($tableName, $columns, $sourceId);

            } elseif ($indexType === 'unique') {
                $generator->addUniqueIndex($tableName, $columns, $sourceId);

            } elseif ($indexType === 'primary') {
                $generator->addPrimaryIndex($tableName, $columns, $sourceId);

            } else {
                throw new InvalidArgumentException("Unknow index type '$indexType'.");
            }
        }


        protected function addHasManyRelationship(Generator $generator, Relationship\HasMany $relationship, $sourceTable)
        {
            $relationshipTable = $relationship->getRelationshipTable();
            $sourceColumn = $relationship->getColumnReferencingSourceTable();
            $targetTable = $relationship->getTargetTable();
            $targetColumn = $relationship->getColumnReferencingTargetTable();

            if ($this->mapper->getRelationshipTable($sourceTable, $targetTable) === $relationshipTable) {
                $generator->addHasManyTable(
                    $relationshipTable,
                    $sourceTable,
                    $sourceColumn,
                    $targetTable,
                    $targetColumn
                );

            } else {
                $generator->addHasManyTable(
                    $relationshipTable,
                    $targetTable,
                    $targetColumn,
                    $sourceTable,
                    $sourceColumn
                );
            }
            // $relationshipTable = $generator->createTable();
            // $generator->addColumn($relationship->getRelationshipTable(), $relationship->getColumnReferencingSourceTable(), NULL, NULL);
            // $generator->addColumn($relationship->getRelationshipTable(), $relationship->getColumnReferencingTargetTable(), NULL, NULL);
        }


        /**
         * Returns list of FQN class names.
         * @return string[]
         */
        protected function findEntities()
        {
            $robot = new Nette\Loaders\RobotLoader;
            $robot->addDirectory($this->directories);
            $robot->acceptFiles = '*.php';
            $robot->rebuild();
            $classes = array_keys($robot->getIndexedClasses());
            $entities = array();

            foreach ($classes as $class) {
                $accept = class_exists($class)
                    && ($rc = new \ReflectionClass($class))
                    && $rc->isSubclassOf('LeanMapper\\Entity')
                    && !$rc->isAbstract();

                if ($accept) {
                    $entities[] = $class;
                }
            }

            return $entities;
        }


        /**
         * @return Reflection\EntityReflection[]
         */
        protected function getFamilyLine(Reflection\EntityReflection $reflection)
        {
            $line = array($member = $reflection);

            while ($member = $member->getParentClass()) {
                if ($member->name === 'LeanMapper\Entity') {
                    break;
                }

                $line[] = $member;
            }

            return array_reverse($line);
        }
    }