--- a/src/main/kotlin/name/blackcap/passman/MergeSubcommand.kt	Sat Oct 01 20:43:59 2022 -0700
+++ b/src/main/kotlin/name/blackcap/passman/MergeSubcommand.kt	Sat Jan 21 15:39:42 2023 -0800
@@ -1,22 +1,129 @@
 package name.blackcap.passman
 
+import org.apache.commons.cli.*
+import java.sql.ResultSet
+import java.util.*
+import kotlin.system.exitProcess
+
 class MergeSubcommand(): Subcommand() {
+    private companion object {
+        const val FORCE = "force"
+        const val HELP = "help"
+    }
+    private lateinit var commandLine: CommandLine
+    private lateinit var db: Database
+
     override fun run(args: Array<String>) {
-        /*
-         * To merge, plow through both the old and the new databases in the same
-         * order. By id is sorta idiosyncratic by human standards, but why not?
-         * If the entries do not match, write the lowest-numbered one to the
-         * output database and read the next record from where the lowest-numbered
-         * one came. If they do match, rely on modified time (fall back to created
-         * time if null) to sort out the winner. Continue till we hit the end
-         * of one database, then "drain" the other. Preserve time stamps.
-         *
-         * Maybe do something special (warning? confirmation prompt?) on mismatched
-         * creation times, as this means a new record was created w/o knowledge
-         * of an existing one. Choices should be to clobber w/ newest, pick one
-         * manually, or rename one so the other can persist under original name.
-         *
-         */
-        error("not yet implemented")
+        parseArguments(args)
+        db = Database.open()
+        doMerge()
+    }
+
+    private fun parseArguments(args: Array<String>) {
+        val options = Options().apply {
+            addOption("f", MergeSubcommand.FORCE, false, "Do not ask before overwriting.")
+            addOption("h", MergeSubcommand.HELP, false, "Print this help message.")
+        }
+        try {
+            commandLine = DefaultParser().parse(options, args)
+        } catch (e: ParseException) {
+            die(e.message ?: "syntax error", 2)
+        }
+        if (commandLine.hasOption(MergeSubcommand.HELP)) {
+            HelpFormatter().printHelp("$SHORTNAME merge [options] other_database", options)
+            exitProcess(0)
+        }
+        if (commandLine.args.isEmpty()) {
+            die("expecting other database name", 2)
+        }
+        if (commandLine.args.size > 1) {
+            die("unexpected trailing arguments", 2)
+        }
+    }
+
+    private fun doMerge() {
+        val otherFile = commandLine.args[0]
+        val otherDb = Database.open(
+            fileName = otherFile,
+            passwordPrompt = "Key for ${see(otherFile)}: ", create = false
+        )
+        otherDb.connection.prepareStatement("select name, username, password, notes, created, modified, accessed from passwords").use { stmt ->
+            val results = stmt.executeQuery()
+            while (results.next()) {
+                val otherEntry = makeEntry(results)
+                val thisEntry = getEntry(db, otherEntry.name)
+                if (thisEntry == null) {
+                    doInsert(otherEntry)
+                } else {
+                    doCompare(thisEntry, otherEntry)
+                    thisEntry.password.clear()
+                }
+                otherEntry.password.clear()
+            }
+        }
     }
+
+    private fun makeEntry(results: ResultSet) = Entry(
+        name = results.getDecryptedString(1, db.encryption)!!,
+        username = results.getDecryptedString(2, db.encryption)!!,
+        password = results.getDecrypted(3, db.encryption)!!,
+        notes = results.getDecryptedString(4, db.encryption),
+        created = results.getDate(5),
+        modified = results.getDate(6),
+        accessed = results.getDate(7)
+    )
+
+    private fun getEntry(otherDb: Database, name: String): Entry? {
+        otherDb.connection.prepareStatement("select name, username, password, notes, created, modified, accessed from passwords where id = ?").use { stmt ->
+            stmt.setLong(1, otherDb.makeKey(name))
+            val results = stmt.executeQuery()
+            return if (results.next()) makeEntry(results) else null
+        }
+    }
+
+    private fun doInsert(entry: Entry) {
+        db.connection.prepareStatement("insert into passwords (id, name, username, password, notes, created, modified, accessed) values (?, ?, ?, ?, ?, ?, ?, ?)")
+            .use {
+                it.setLong(1, db.makeKey(entry.name))
+                it.setEncryptedString(2, entry.name, db.encryption)
+                it.setEncryptedString(3, entry.username, db.encryption)
+                it.setEncrypted(4, entry.password, db.encryption)
+                it.setEncryptedString(5, entry.notes, db.encryption)
+                it.setLongOrNull(6, entry.created?.time)
+                it.setLongOrNull(7, entry.modified?.time)
+                it.setLongOrNull(8, entry.accessed?.time)
+                it.executeUpdate()
+            }
+    }
+
+    private fun doCompare(thisEntry: Entry, otherEntry: Entry) {
+        if (otherEntry.modifiedOrCreated.after(thisEntry.modifiedOrCreated) && okToChange(thisEntry, otherEntry)) {
+            db.connection.prepareStatement("update passwords set name = ?, username = ?, password = ?, notes = ?, modified = ? where id = ?").use {
+                it.setEncryptedString(1, otherEntry.name, db.encryption)
+                it.setEncryptedString(2, otherEntry.username, db.encryption)
+                it.setEncrypted(3, otherEntry.password, db.encryption)
+                it.setEncryptedString(4, otherEntry.notes, db.encryption)
+                it.setLong(5, otherEntry.modifiedOrCreated.time)
+                it.setLong(6, db.makeKey(thisEntry.name))
+                it.executeUpdate()
+            }
+        }
+    }
+
+    private fun okToChange(thisEntry: Entry, otherEntry: Entry): Boolean {
+        if (commandLine.hasOption(MergeSubcommand.FORCE)) {
+            return true
+        }
+        val REDACTED = "(redacted)"
+        println("EXISTING ENTRY:")
+        thisEntry.printLong(REDACTED)
+        println()
+        println("NEWER ENTRY:")
+        otherEntry.printLong(REDACTED)
+        println()
+        val answer = name.blackcap.passman.readLine("OK to overwrite existing entry? ")
+        println()
+        return answer.trimStart().firstOrNull()?.uppercaseChar() in setOf('T', 'Y')
+    }
+
 }