export class SegmentsWithScopeRepository extends DefaultCrudRepository<SegmentsWithScope,
  typeof SegmentsWithScope.prototype.matchId,
  SegmentsWithScopeRelations> {
  constructor(
    @inject('datasources.postgresDs') dataSource: PostgresDsDataSource,
  ) {
    super(SegmentsWithScope, dataSource);
  }

  customQuery(filter?: Filter) {
    const query = this.buildSelect(SegmentsWithScope.modelName, filter);
    return this.execute(query.sql, query.params);
  }

  buildSelect(model: string, filter?: Filter): ParameterizedSQL {
    if (!filter?.order) {
      const idNames = this.dataSource.connector!.idNames(model);
      if (idNames?.length) {
        filter = {
          ...filter ?? {},
          order: idNames,
        };
      }
    }

    const columnNames = this.dataSource.connector!.buildColumnNames(model, filter);
    const tableName = this.dataSource.connector!.tableEscaped(model);
    let selectStmt = new ParameterizedSQL(`SELECT ${columnNames} FROM ${tableName}`);

    if (filter) {
      if (filter.where) {
        const whereStmt = this.buildWhere(model, filter.where);
        selectStmt.merge(whereStmt);
      }

      if (filter.order) {
        selectStmt.merge(this.dataSource.connector!.buildOrderBy(model, filter.order));
      }

      if (filter.limit || filter.skip || filter.offset) {
        selectStmt = this.dataSource.connector!.applyPagination(
          model, selectStmt, filter,
        );
      }
    }
    return this.parameterize(selectStmt);
  }

  parameterize(ps: ParameterizedSQL): ParameterizedSQL {
    return this.dataSource.connector!.parameterize(ps);
  }

  buildWhere(model: string, where?: Where) {
    const whereClause = this._buildWhere(model, where);
    if (whereClause.sql) {
      whereClause.sql = 'WHERE ' + whereClause.sql;
    }
    return whereClause;
  }

  _buildWhere(model: string, where?: Where<SegmentsWithScope>): ParameterizedSQL {
    let columnValue, sqlExp;
    if (!where) {
      return new ParameterizedSQL('');
    }
    if (typeof where !== 'object' || Array.isArray(where)) {
      console.log('Invalid value for where: %j', where);
      return new ParameterizedSQL('');
    }
    const props = this.getModelDefinition(model).properties;

    const whereStmts = [];
    for (const key in where) {
      const stmt = new ParameterizedSQL('', []);
      // Handle and/or operators
      if (key === 'and' || key === 'or') {
        const branches = [];
        let branchParams: unknown[] = [];
        // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
        // @ts-ignore
        const clauses: Where<SegmentsWithScope>[] = where[key];
        if (Array.isArray(clauses)) {
          for (let i = 0, n = clauses.length; i < n; i++) {
            const stmtForClause = this._buildWhere(model, clauses[i]);
            if (stmtForClause.sql) {
              stmtForClause.sql = '(' + stmtForClause.sql + ')';
              branchParams = branchParams.concat(stmtForClause.params);
              branches.push(stmtForClause.sql);
            }
          }
          stmt.merge({
            sql: branches.join(' ' + key.toUpperCase() + ' '),
            params: branchParams,
          });
          whereStmts.push(stmt);
          continue;
        }
        // The value is not an array, fall back to regular fields
      }
      let p = props[key];

      if (p == null && isNested(key)) {
        // See if we are querying nested json
        p = objectPath.get(props, key);
      }

      if (p == null) {
        // Unknown property, ignore it
        console.log('Unknown property %s is skipped for model %s', key, model);
        continue;
      }
      // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
      // @ts-ignore
      let expression = where[key];
      const columnName = this.columnEscaped(model, key);
      // eslint-enable one-var
      if (expression === null || expression === undefined) {
        stmt.merge(columnName + ' IS NULL');
      } else if (expression && expression.constructor === Object) {
        const operator = Object.keys(expression)[0];
        // Get the expression without the operator
        expression = expression[operator];
        if (operator === 'inq' || operator === 'nin' || operator === 'between') {
          columnValue = [];
          if (Array.isArray(expression)) {
            // Column value is a list
            for (let j = 0, m = expression.length; j < m; j++) {
              columnValue.push(this.toColumnValue(p, expression[j], true));
            }
          } else {
            columnValue.push(this.toColumnValue(p, expression, true));
          }
          if (operator === 'between') {
            // BETWEEN v1 AND v2
            const v1 = columnValue[0] === undefined ? null : columnValue[0];
            const v2 = columnValue[1] === undefined ? null : columnValue[1];
            columnValue = [v1, v2];
          } else {
            // IN (v1,v2,v3) or NOT IN (v1,v2,v3)
            if (columnValue.length === 0) {
              if (operator === 'inq') {
                columnValue = [null];
              } else {
                // nin () is true
                continue;
              }
            }
          }
        } else if (operator === 'regexp' && expression instanceof RegExp) {
          // do not coerce RegExp based on property definitions
          columnValue = expression;
        } else {
          columnValue = this.toColumnValue(p, expression, true);
        }
        sqlExp = this.buildExpression(columnName, operator as Operators, columnValue, p);
        stmt.merge(sqlExp);
      } else {
        // The expression is the field value, not a condition
        columnValue = this.toColumnValue(p, expression);
        if (columnValue === null) {
          stmt.merge(columnName + ' IS NULL');
        } else {
          if (columnValue instanceof ParameterizedSQL) {
            if (p.type.name === 'GeoPoint')
              stmt.merge(columnName + '~=').merge(columnValue);
            else
              stmt.merge(columnName + '=').merge(columnValue);
          } else {
            stmt.merge({
              sql: columnName + '=?',
              params: [columnValue],
            });
          }
        }
      }
      whereStmts.push(stmt);
    }
    let params: unknown[] = [];
    const sqls = [];
    for (let k = 0, s = whereStmts.length; k < s; k++) {
      sqls.push(whereStmts[k].sql);
      params = params.concat(whereStmts[k].params);
    }
    return new ParameterizedSQL({
      sql: sqls.join(' AND '),
      params: params,
    });
  }

  toColumnValue(prop: PropertyDefinition, val: unknown, isWhereClause = false) {
    const isArrayDataType = dataTypeIsArray(prop.postgresql?.dataType);
    if (Array.isArray(prop.type)) {
      return Array.isArray(val)
        ? (isArrayDataType ? val : JSON.stringify(val))
        : (isArrayDataType ? JSON.parse(val as string) : val);
    }
    return this.dataSource.connector!.toColumnValue(prop, val, isWhereClause);
  }

  buildExpression(propName: string, operator: string, propValue: unknown, propertyDefinition: PropertyDefinition) {
    const isArray = dataTypeIsArray(propertyDefinition.postgresql?.dataType);
    let op;
    if (isArray) {
      switch (operator) {
        case 'overlap':
          op = '&&';
          break;
        case 'contains':
          op = '@>';
          break;
        case 'isContainedBy':
          op = '<@';
          break;
        default:
          return this.dataSource.connector!.buildExpression(
            propName, operator, propValue, propertyDefinition,
          );
      }
      const dataType = propertyDefinition.postgresql?.dataType;
      return new ParameterizedSQL(`${propName} ${op} ?::${dataType}`, [propValue]);
    }

    return this.dataSource.connector!.buildExpression(
      propName, operator, propValue, propertyDefinition,
    );
  }

  getModelDefinition(...args: unknown[]) {
    return this.dataSource.connector!.getModelDefinition(...args);
  }

  columnEscaped(...args: unknown[]) {
    return this.dataSource.connector!.columnEscaped(...args);
  }
}

const dataTypeIsArray = (type: string) => type.includes('[]');
const isNested = (prop: string) => prop.split('.').length > 1;