import { binaryToSQL } from './binary'

import { columnRefToSQL } from './column'

import { exprToSQL } from './expr'

import { valuesToSQL } from './insert'

import { intervalToSQL } from './interval'

import { commonOptionConnector, hasVal, identifierToSql, literalToSQL, toUpper } from './util'

function unnestToSQL(unnestExpr) {

const { type, as, expr, with_offset: withOffset } = unnestExpr

const result = [

`${toUpper(type)}(${expr && exprToSQL(expr) || ''})`,

commonOptionConnector('AS', identifierToSql, as),

commonOptionConnector(

toUpper(withOffset && withOffset.keyword),

identifierToSql,

withOffset && withOffset.as

),

]

return result.filter(hasVal).join(' ')

}

function pivotOperatorToSQL(operator) {

const { as, column, expr, in_expr, type } = operator

const result = [

exprToSQL(expr),

'FOR',

columnRefToSQL(column),

binaryToSQL(in_expr),

]

const sql = [`${toUpper(type)}(${result.join(' ')})`]

if (as) sql.push('AS', identifierToSql(as))

return sql.join(' ')

}

function operatorToSQL(operator) {

if (!operator) return

const { type } = operator

switch (type) {

case 'pivot':

case 'unpivot':

return pivotOperatorToSQL(operator)

default:

return ''

}

}

function tableHintToSQL(tableHintExpr) {

if (!tableHintExpr) return

const { keyword, expr, index, index_columns, parentheses, prefix } = tableHintExpr

const result = []

switch (keyword.toLowerCase()) {

case 'forceseek':

result.push(toUpper(keyword), `(${identifierToSql(index)}`, `(${index_columns.map(exprToSQL).filter(hasVal).join(', ')}))`)

break

case 'spatial_window_max_cells':

result.push(toUpper(keyword), '=', exprToSQL(expr))

break

case 'index':

result.push(toUpper(prefix), toUpper(keyword), parentheses ? `(${expr.map(identifierToSql).join(', ')})` : `= ${identifierToSql(expr)}`)

break

default:

result.push(exprToSQL(expr))

}

return result.filter(hasVal).join(' ')

}

function tableTumbleToSQL(tumble) {

if (!tumble) return ''

const { data: tableInfo, timecol, size } = tumble

const fullTableName = [identifierToSql(tableInfo.db), identifierToSql(tableInfo.table)].filter(hasVal).join('.')

const result = ['TABLE(TUMBLE(TABLE', fullTableName, `DESCRIPTOR(${columnRefToSQL(timecol)})`, `${intervalToSQL(size)}))`]

return result.filter(hasVal).join(' ')

}

function tableToSQL(tableInfo) {

if (toUpper(tableInfo.type) === 'UNNEST') return unnestToSQL(tableInfo)

const { table, db, as, expr, operator, prefix: prefixStr, schema, server, tablesample, table_hint } = tableInfo

const serverName = identifierToSql(server)

const database = identifierToSql(db)

const schemaStr = identifierToSql(schema)

let tableName = table && identifierToSql(table)

if (expr) {

const exprType = expr.type

switch (exprType) {

case 'values':

const { parentheses, values, prefix } = expr

const valueSQL = [parentheses && '(', '', parentheses && ')']

let valuesExpr = valuesToSQL(values)

if (prefix) valuesExpr = valuesExpr.split('(').slice(1).map(val => `${toUpper(prefix)}(${val}`).join('')

valueSQL[1] = `VALUES ${valuesExpr}`

tableName = valueSQL.filter(hasVal).join('')

break

case 'tumble':

tableName = tableTumbleToSQL(expr)

break

default:

tableName = exprToSQL(expr)

}

}

tableName = [toUpper(prefixStr), tableName].filter(hasVal).join(' ')

let str = [serverName, database, schemaStr, tableName].filter(hasVal).join('.')

if (tableInfo.parentheses) str = `(${str})`

const result = [str]

if (tablesample) {

const tableSampleSQL = ['TABLESAMPLE', exprToSQL(tablesample.expr), literalToSQL(tablesample.repeatable)].filter(hasVal).join(' ')

result.push(tableSampleSQL)

}

result.push(commonOptionConnector('AS', identifierToSql, as), operatorToSQL(operator))

if (table_hint) result.push(toUpper(table_hint.keyword), `(${table_hint.expr.map(tableHintToSQL).filter(hasVal).join(', ')})`)

return result.filter(hasVal).join(' ')

}

/**

* @param {Array} tables

* @return {string}

*/

function tablesToSQL(tables) {

if (!tables) return ''

if (!Array.isArray(tables)) {

const { expr, parentheses } = tables

const sql = tablesToSQL(expr)

if (parentheses) return `(${sql})`

return sql

}

const baseTable = tables[0]

const clauses = []

if (baseTable.type === 'dual') return 'DUAL'

clauses.push(tableToSQL(baseTable))

for (let i = 1; i < tables.length; ++i) {

const joinExpr = tables[i]

const { on, using, join } = joinExpr

const str = []

str.push(join ? ` ${toUpper(join)}` : ',')

str.push(tableToSQL(joinExpr))

str.push(commonOptionConnector('ON', exprToSQL, on))

if (using) str.push(`USING (${using.map(identifierToSql).join(', ')})`)

clauses.push(str.filter(hasVal).join(' '))

}

return clauses.filter(hasVal).join('')

}

function tableOptionToSQL(tableOption) {

const { keyword, symbol, value } = tableOption

const sql = [keyword.toUpperCase()]

if (symbol) sql.push(symbol)

let val = value

switch (keyword) {

case 'partition by':

case 'default collate':

val = exprToSQL(value)

break

case 'options':

val = `(${value.map(tableOptionItem => [tableOptionItem.keyword, tableOptionItem.symbol, exprToSQL(tableOptionItem.value)].join(' ')).join(', ')})`

break

case 'cluster by':

val = value.map(exprToSQL).join(', ')

break

}

sql.push(val)

return sql.join(' ')

}

export {

operatorToSQL,

tableHintToSQL,

tableTumbleToSQL,

tablesToSQL,

tableOptionToSQL,

tableToSQL,

unnestToSQL,

}