///|
priv struct Rename {
  store : Store
  table : String
  new_table : String
  column : String
  new_column : String
  mut referenced : Bool
}

///|
fn rename_table_name(r : Rename, name : String) -> String {
  if identifier(name) == identifier(r.table) {
    r.new_table
  } else {
    name
  }
}

///|
fn rename_column_name(r : Rename, table : String, name : String) -> String {
  if r.column != "" &&
    identifier(table) == identifier(r.table) &&
    identifier(name) == identifier(r.column) {
    r.referenced = true
    r.new_column
  } else {
    name
  }
}

///|
fn rename_expr(r : Rename, e : Expr, scope : Array[(String, String)]) -> Expr {
  match e {
    Column(q, n) => {
      let mut owner = ""
      if q != "" {
        for (qualifier, table) in scope {
          if identifier(qualifier) == identifier(q) {
            owner = table
            break
          }
        }
      } else {
        for (qualifier, table) in scope {
          if qualifier == "old" || qualifier == "new" {
            continue
          }
          if r.store.tables.any(t => {
              identifier(t.name) == identifier(table) &&
              t.columns.any(c => identifier(c.name) == identifier(n))
            }) {
            owner = table
            break
          }
        }
      }
      Column(
        if identifier(owner) == identifier(r.table) &&
          identifier(q) == identifier(r.table) {
          r.new_table
        } else {
          q
        },
        rename_column_name(r, owner, n),
      )
    }
    Star(q) =>
      Star(
        if identifier(q) == identifier(r.table) &&
          scope.any(s => {
            identifier(s.0) == identifier(q) &&
            identifier(s.1) == identifier(r.table)
          }) {
          r.new_table
        } else {
          q
        },
      )
    Unary(op, e) => Unary(op, rename_expr(r, e, scope))
    Binary(op, a, b) =>
      Binary(op, rename_expr(r, a, scope), rename_expr(r, b, scope))
    Cast(e, t) => Cast(rename_expr(r, e, scope), t)
    Collate(e, c) => Collate(rename_expr(r, e, scope), c)
    Call(name, args) => Call(name, args.map(e => rename_expr(r, e, scope)))
    Between(a, b, c) =>
      Between(
        rename_expr(r, a, scope),
        rename_expr(r, b, scope),
        rename_expr(r, c, scope),
      )
    Case(base, arms, other) =>
      Case(
        base.map(e => rename_expr(r, e, scope)),
        arms.map(p => (rename_expr(r, p.0, scope), rename_expr(r, p.1, scope))),
        rename_expr(r, other, scope),
      )
    ScalarSelect(s) => ScalarSelect(rename_select(r, s, scope))
    Exists(s) => Exists(rename_select(r, s, scope))
    InSelect(e, s) =>
      InSelect(rename_expr(r, e, scope), rename_select(r, s, scope))
    RowNumber(orders) =>
      RowNumber(
        orders.map(o => {
          ..o,
          expression: rename_expr(r, o.expression, scope),
        }),
      )
    Window(name, args, parts, orders, frame) =>
      Window(
        name,
        args.map(e => rename_expr(r, e, scope)),
        parts.map(e => rename_expr(r, e, scope)),
        orders.map(o => {
          ..o,
          expression: rename_expr(r, o.expression, scope),
        }),
        frame,
      )
    _ => e
  }
}

///|
fn rename_select(
  r : Rename,
  s : Selection,
  outer : Array[(String, String)],
) -> Selection {
  let scope = s.sources.map(source => (source.qualifier, source.name)) + outer
  {
    ..s,
    sources: s.sources.map(source => {
      ..source,
      name: rename_table_name(r, source.name),
      qualifier: if identifier(source.name) == identifier(r.table) &&
        identifier(source.qualifier) == identifier(r.table) {
        r.new_table
      } else {
        source.qualifier
      },
      on: rename_expr(r, source.on, scope),
    }),
    ctes: s.ctes.map(p => (p.0, rename_select(r, p.1, outer))),
    projections: s.projections.map(p => {
      let expression = rename_expr(r, p.expression, scope)
      {
        ..p,
        expression,
        label: if !p.explicit_label && expression is Column(_, n) {
          n
        } else {
          p.label
        },
      }
    }),
    predicate: rename_expr(r, s.predicate, scope),
    groups: s.groups.map(e => rename_expr(r, e, scope)),
    having: rename_expr(r, s.having, scope),
    orders: s.orders.map(o => {
      ..o,
      expression: rename_expr(r, o.expression, scope),
    }),
    compound: s.compound.map(arms => {
      arms.map(p => (p.0, rename_select(r, p.1, outer)))
    }),
  }
}

///|
fn rename_data(
  r : Rename,
  statement : DataStatement,
  outer : Array[(String, String)],
) -> DataStatement {
  match statement {
    PreparedSelect(s) => PreparedSelect(rename_select(r, s, outer))
    PreparedInsert(i) => {
      let scope = [(i.table, i.table), ("excluded", i.table)] + outer
      PreparedInsert({
        ..i,
        table: rename_table_name(r, i.table),
        columns: i.columns.map(n => rename_column_name(r, i.table, n)),
        values: i.values.map(row => row.map(e => rename_expr(r, e, outer))),
        selection: i.selection.map(s => rename_select(r, s, outer)),
        target: i.target.map(n => rename_column_name(r, i.table, n)),
        target_predicate: i.target_predicate.map(e => rename_expr(r, e, scope)),
        updates: i.updates.map(p => {
          (rename_column_name(r, i.table, p.0), rename_expr(r, p.1, scope))
        }),
        predicate: rename_expr(r, i.predicate, scope),
        returning: i.returning.map(p => {
          ..p,
          expression: rename_expr(r, p.expression, scope),
        }),
      })
    }
    PreparedUpdate(name, setters, predicate, returning) => {
      let scope = [(name, name)] + outer
      PreparedUpdate(
        rename_table_name(r, name),
        setters.map(p => {
          (rename_column_name(r, name, p.0), rename_expr(r, p.1, scope))
        }),
        rename_expr(r, predicate, scope),
        returning.map(p => {
          ..p,
          expression: rename_expr(r, p.expression, scope),
        }),
      )
    }
    PreparedDelete(name, predicate, returning) => {
      let scope = [(name, name)] + outer
      PreparedDelete(
        rename_table_name(r, name),
        rename_expr(r, predicate, scope),
        returning.map(p => {
          ..p,
          expression: rename_expr(r, p.expression, scope),
        }),
      )
    }
    _ => statement
  }
}

///|
fn rename_object(r : Rename, o : SchemaObject) -> SchemaObject {
  let scope = [(o.table, o.table), ("old", o.table), ("new", o.table)]
  let trigger = o.trigger.map(t => {
    ..t,
    columns: t.columns.map(n => rename_column_name(r, o.table, n)),
    condition: rename_expr(r, t.condition, scope),
    body: t.body.map(s => {
      rename_data(r, s, [("old", o.table), ("new", o.table)])
    }),
  })
  let next = {
    ..o,
    table: if o.kind == "view" {
      o.table
    } else {
      rename_table_name(r, o.table)
    },
    columns: o.columns.map(n => rename_column_name(r, o.table, n)),
    index_terms: o.index_terms.map(orders => {
      orders.map(order => {
        ..order,
        expression: rename_expr(r, order.expression, scope),
      })
    }),
    index_predicate: o.index_predicate.map(e => rename_expr(r, e, scope)),
    selection: o.selection.map(s => rename_select(r, s, [])),
    trigger,
  }
  next
}

///|
fn migrate_schema(
  store : Store,
  name : String,
  new_table : String,
  column : String,
  new_column : String,
  drop : Bool,
  quoted~ : Bool = false,
) -> Unit raise SqlError {
  let original = copy_store(store)
  let table = get_table(original, name)
  let index = if column == "" { -1 } else { column_index(table, column) }
  if column == "" {
    guard !store.tables.any(t => identifier(t.name) == identifier(new_table)) &&
      !store.objects.any(o => identifier(o.name) == identifier(new_table)) else {
      fail("table already exists")
    }
  } else if !drop {
    guard !table.columns.any(c => identifier(c.name) == identifier(new_column)) else {
      fail("duplicate column name")
    }
  }
  if drop {
    guard table.columns.length() > 1 &&
      table.columns[index].primary == 0 &&
      !table.unique_keys.any(key => key.contains(index)) else {
      fail("cannot drop PRIMARY KEY or UNIQUE column")
    }
  }
  let rename : Rename = {
    store: original,
    table: name,
    new_table,
    column,
    new_column,
    referenced: false,
  }
  let objects = original.objects.map(o => {
    let next = rename_object(rename, o)
    let sql = migration_sql(o.sql, rename, o.table, o.kind, drop, quoted)
    ignore(next)
    guard parse_statement(lex(sql)) is CreateObject(parsed, _) else {
      fail("invalid migrated schema object")
    }
    parsed
  })
  if drop {
    guard !rename.referenced else { fail("cannot drop referenced column") }
  }
  let tables : Array[Table] = []
  for t in original.tables {
    let scope = [(t.name, t.name)]
    let checks = t.checks.map(e => rename_expr(rename, e, scope))
    let foreign_keys = t.foreign_keys.map(fk => {
      let targets = fk.targets.map(names => {
        names.map(n => rename_column_name(rename, fk.parent, n))
      })
      let target = rename_column_name(rename, fk.parent, fk.target)
      if drop &&
        identifier(t.name) == identifier(name) &&
        foreign_columns(fk).contains(index) {
        rename.referenced = true
      }
      let columns = if drop && identifier(t.name) == identifier(name) {
        fk.columns.map(cols => cols.map(i => if i > index { i - 1 } else { i }))
      } else {
        fk.columns
      }
      {
        ..fk,
        parent: rename_table_name(rename, fk.parent),
        target,
        targets,
        columns,
        column: if drop &&
          identifier(t.name) == identifier(name) &&
          fk.column > index {
          fk.column - 1
        } else {
          fk.column
        },
      }
    })
    if drop {
      guard !rename.referenced else { fail("cannot drop referenced column") }
    }
    let own = identifier(t.name) == identifier(name)
    let columns = t.columns
      .mapi((i, c) => (i, c))
      .filter(p => !drop || !own || p.0 != index)
      .map(p => {
        ..p.1,
        name: if own && p.0 == index {
          new_column
        } else {
          p.1.name
        },
      })
    let next = {
      ..t,
      name: if own {
        new_table
      } else {
        t.name
      },
      columns,
      checks,
      foreign_keys,
      unique_keys: if drop && own {
        t.unique_keys.map(key => key.map(i => if i > index { i - 1 } else { i }))
      } else {
        t.unique_keys
      },
      rows: if drop && own {
        row_pages(
          t.rows.map(row => {
            ..row,
            values: row.values
            .mapi((i, v) => (i, v))
            .filter(p => p.0 != index)
            .map(p => p.1),
          }),
        )
      } else {
        t.rows
      },
    }
    tables.push({
      ..next,
      sql: migration_sql(t.sql, rename, t.name, "table", drop, quoted),
    })
  }
  store.tables.clear()
  for t in tables {
    store.tables.push(t)
  }
  store.objects.clear()
  for o in objects {
    store.objects.push(o)
  }
  schema_changed(store)
  validate_image(store)
  for o in store.objects {
    if o.kind == "view" && o.selection is Some(s) {
      ignore(selection_template(s, evaluation(store, [], [])))
    }
    if o.kind == "trigger" {
      prepare_trigger(store, get_table(store, o.table), o)
    }
  }
}