'("1d609285d297920b97b0d230360a8d7c3f930edcf1abe96a1d82356f9a5e228d" "abe5ee8858cd1fbe36304a8c3b2315d3e0a4ef7c8588fcc45d1c23eafb725bb6" "d600c677f1777c1e4bfb066529b5b73c0179d0499dd4ffa3f599a0fb0cfbd501" "30289fa8d502f71a392f40a0941a83842152a68c54ad69e0638ef52f04777a4c" "c7f10959cb1bc7a36ee355c765a1768d48929ec55dde137da51077ac7f899521" "773e0bfa5450c75d613cbf29734cdc876c3d59dbf85b93cff3015a8687dea158" "bf798e9e8ff00d4bf2512597f36e5a135ce48e477ce88a0764cfb5d8104e8163" "1436d643b98844555d56c59c74004eb158dc85fc55d2e7205f8d9b8c860e177f" "1e9001d2f6ffb095eafd9514b4d5974b720b275143fbc89ea046495a99c940b0" "f11e219c9d043cbd5f4b2e01713c2c24a948a98bed48828dc670bd64ae771aa1" "8f97d5ec8a774485296e366fdde6ff5589cf9e319a584b845b6f7fa788c9fa9a" "2642a1b7f53b9bb34c7f1e032d2098c852811ec2881eec2dc8cc07be004e45a0" "5111a41453244802afd93eed1a434e612a8afbdf19c52384dffab129258bab6e" "0329c772ed96053a73b9ddddf96c1183e23c267955bbdf78e7933057ce9da04b" "36ca8f60565af20ef4f30783aa16a26d96c02df7b4e54e9900a5138fb33808da" "23b564cfb74d784c73167d7de1b9a067bcca00719f81e46d09ee71a12ef7ee82" "f7ef6451d988d6e2fc86deea398eee02b3371703d88f265d31a011bd240dcf99" "3d4df186126c347e002c8366d32016948068d2e9198c496093a96775cc3b3eaa" "c560237b7505f67a271def31c706151afd7aa6eba9f69af77ec05bde5408dbcd" "24cb0b5666e1e17fb6a378c413682f57fe176775eda015eb0a98d65fbb64b127" "b0eb9e6e6dcb29c6ec4bcd72605188f482d52ee019cb0ccc73b5404be4f3a6e7" "08a89acffece58825e75479333109e01438650d27661b29212e6560070b156cf" "c9ddf33b383e74dac7690255dd2c3dfa1961a8e8a1d20e401c6572febef61045" "a22f40b63f9bc0a69ebc8ba4fbc6b452a4e3f84b80590ba0a92b4ff599e53ad0" "585942bb24cab2d4b2f74977ac3ba6ddbd888e3776b9d2f993c5704aa8bb4739" "fa2af0c40576f3bde32290d7f4e7aa865eb6bf7ebe31eb9e37c32aa6f4ae8d10" "85d1dbf2fc0e5d30f236712b831fb24faf6052f3114964fdeadede8e1b329832" "bffb799032a7404b33e431e6a1c46dc0ca62f54fdd20744a35a57c3f78586646" "779df25c6240f183dd378811465566082eacc3c86ed260835382cb5c1dc54de3" "eee70baee3a2d093a98fa344480d2330eb3a17f8dfa883cc41d8008cd46fa669" "b70474b8a631f73868f01fdb047f102dd36325ecbf6789962e613e9195e165d7" "ccdd152be99a9250f5c24e09860911ff4b1519a8c4c73e4d67364514a3359f71" "ba913d12adb68e9dadf1f43e6afa8e46c4822bb96a289d5bf1204344064f041e" "146614f131e5029df850a268aff1f0e3ae16734a119904eab133755b574da37d" "c8935cb969e24ff30a6ee1da011eadc156b9f128a3b0a39cc664628838a644ad" "767a6105de48707dd6a593b62c05a7bf4ee9930c86e3225410110d95906772d6" "39546362fed4d5201b2b386dc21f21439497c9eec5fee323d953b3e230e4083e" "2f4f50d98073c01038b518066840638455657dc91dd1a225286d573926f36914" "80ae3a89f1eca6fb94a525004f66b544e347c6f756aaafb728c7cdaef85ea1f5" "7b1a2c8ec90a30cc5d039db0e52f192a291f4c3655103cf669721f94028eac27" "bcd0237b2a5b7897e482458cc62c4f3fa3d9d7f9a9667338e67d4c7a8e009819" "8e79884e89740cf6b7e0210f52e4ac995dc1f1a9a17151bfcfb4d660757a011b" "454c1c9ce70f7d807c51c890910365fd3c64a9e63f596511e9ff57dd97bbeea8" "387b487737860e18cbb92d83a42616a67c1edfd0664d521940e7fbf049c315ae" "6231254e74298a1cf8a5fee7ca64352943de4b495e615c449e9bb27e2ccae709" "3577ee091e1d318c49889574a31175970472f6f182a9789f1a3e9e4513641d86" "cbd85ab34afb47003fa7f814a462c24affb1de81ebf172b78cb4e65186ba59d2" "8f5b54bf6a36fe1c138219960dd324aad8ab1f62f543bed73ef5ad60956e36ae" "9d8ad1c413fccc14d992f6bed0ead11f1798a05ee8913daaa24a24604c212b61" "e246ff6951678c835ab95aedb99a48fdd665656eadf8b8bc0a4f60e17fbc6b7e" "e57eec7e0399272aaca7985a5cc94f3a2675db4cd2dbd79a99c72786e489e43c" "d0fd069415ef23ccc21ccb0e54d93bdbb996a6cce48ffce7f810826bb243502c" "ffba0482d3548c9494e84c1324d527f73ea4e43fff8dfd0e48faa8fc6d5c2bc7" "9e816bc85b64963710efdbc57db8545b53f7f359b0736e0b36fbc9efe07f12f4" "6ac7c0f959f0d7853915012e78ff70150bfbe2a69a1b703c3ac4184f9ae3ae02" "845103fcb9b091b0958171653a4413ccfad35552bc39697d448941bcbe5a660d" "bc836bf29eab22d7e5b4c142d201bcce351806b7c1f94955ccafab8ce5b20208" "7f6d4aebcc44c264a64e714c3d9d1e903284305fd7e319e7cb73345a9994f5ef" "10a31b6c251640d04b2fa74bd2c05aaaee915cbca6501bcc82820cdc177f5a93" "6e933f1668e124ec17fc7b6547f65ba760e06efb568a6c8091c600c67827e592" "02199888a97767d7779269a39ba2e641d77661b31b3b8dd494b1a7250d1c8dc1" "2a49f95b19d5926d940db11057077df2d01faaf33e66c5a8d4ee8043a904695f" "bdb4509c123230a059d89fc837c40defdecee8279c741b7f060196b343b2d18d" "ed17fef69db375ae1ced71fdc12e543448827aac5eb7166d2fd05f4c95a7be71" "6515fcc302292f29a94f6ac0c5795c57a396127d5ea31f37fc5f9f0308bbe19f" "5a45c8bf60607dfa077b3e23edfb8df0f37c4759356682adf7ab762ba6b10600" "6c5a5c47749e7992b4da3011595f5470f33e19f29b10564cd4f62faebbe36b91" "8a379e7ac3a57e64de672dd744d4730b3bdb88ae328e8106f95cd81cbd44e0b6" "2035a16494e06636134de6d572ec47c30e26c3447eafeb6d3a9e8aee73732396" "ed0b4fc082715fc1d6a547650752cd8ec76c400ef72eb159543db1770a27caa7" "42b9d85321f5a152a6aef0cc8173e701f572175d6711361955ecfb4943fe93af" "021720af46e6e78e2be7875b2b5b05344f4e21fad70d17af7acfd6922386b61e" "9fcac3986e3550baac55dc6175195a4c7537e8aa082043dcbe3f93f548a3a1e0" "242527ce24b140d304381952aa7a081179a9848d734446d913ca8ef0af3cef21" "8cb818e0658f6cc59928a8f2b2917adc36d882267bf816994e00c5b8fcbf6933" "3fa81193ab414a4d54cde427c2662337c2cab5dd4eb17ffff0d90bca97581eb6" "44247f2a14c661d96d2bff302f1dbf37ebe7616935e4682102b68c0b6cc80095" "73bff6f2ef60f8a1238a9ca666235d258e3acdeeed85d092ca532788dd7a33c4" "05eeb814f74b2fd4f2e6e37b4d604eb9b1daaaedfa5e692f1d485250c6b553eb" "0055e55e6a357a941027139152a67f93376616d3501055d06852f10fdc16bac0" "1f3113447a652b8436a9938bbac71ecaf022cc73ecd0d76182eb9713aa781f17" "b755c709cb46ba4599ab3a3c189a056e9736cbbb39ed9ecfc1ab1aa3d6f79021" "75c5c39809c52d48cb9dcbf1694bf2d27d5f6fd053777c194e0b69d8e49031c0" "54e08527b4f4b127ebf7359acbbbecfab55152da01716c4809682eb71937fd33" "81db42d019a738d388596533bd1b5d66aef3663842172f3696733c0aab05a150" "ef1e992ef341e86397b39ee6b41c1368e1b33d45b0848feac6a8e8d5753daa67" "ad109c1ad8115573f40e22ac2b996693b5d48052fa37b5919f70ea37c62a965e" "b143ad150e25f9b6d09ae313718f85cc785c89445f3369f74bd0d836d5881c56" "dc9a8d70c4f94a28aafc7833f8d05667601968e6c9bf998791c39fcb3e4679c9" "125fd2180e880802ae98b85f282b17f0aa8fa6cb9fc4f33d7fb19a38c40acef0" "4d80487632a0a5a72737a7fc690f1f30266668211b17ba836602a8da890c2118" "9a155066ec746201156bb39f7518c1828a73d67742e11271e4f24b7b178c4710" "4bfced46dcfc40c45b076a1758ca106a947b1b6a6ff79a3281f3accacfb3243c" "31992d4488dba5b28ddb0c16914bf5726dc41588c2b1c1a2fd16516ea92c1d8e" "0e33022384e4db1374827f51e3d9e9a2d56282c2e3568c22f1c12ad80e20cf0c" "83db918b06f0b1df1153f21c0d47250556c7ffb5b5e6906d21749f41737babb7" "47744f6c8133824bdd104acc4280dbed4b34b85faa05ac2600f716b0226fb3f6" "8b313e1793da427e90c034dbe74f3ad9092ac291846c0f855908c42a6bda1ff4" "43c1a8090ed19ab3c0b1490ce412f78f157d69a29828aa977dae941b994b4147" "bc4b650c41b16b98166b35da94b366c6a9e1e7883bbf4937c897fb7bd05aa619" "e9460a84d876da407d9e6accf9ceba453e2f86f8b86076f37c08ad155de8223c" "8ec2e01474ad56ee33bc0534bdbe7842eea74dccfb576e09f99ef89a705f5501" "d606ac41cdd7054841941455c0151c54f8bff7e4e050255dbd4ae4d60ab640c1" "4f2ede02b3324c2f788f4e0bad77f7ebc1874eff7971d2a2c9b9724a50fb3f65" "2b6bd2ebad907ee42b3ffefa4831f348e3652ea8245570cdda67f0034f07db93" "7f3ef7724515515443f961ef87fee655750512473b1f5bf890e2dc7e065f240c" "65d9573b64ec94844f95e6055fe7a82451215f551c45275ca5b78653d505bc42" "39dffaee0e575731c909bb3e4b411f1c4759c3d7510bf02aa5aef322a596dd57" "2cf7f9d1d8e4d735ba53facdc3c6f3271086b6906c4165b12e4fd8e3865469a6" default))

   '("7c0830e1aea024fc0d4e76ba3db9f78cb37c09da2290f38af1a8fe87881007f7" "474513bacf33a439da7b9a5df1dd11a277929d8480752675fc7d5f3816d8fdef" "cfe4d36ed4cf00a541f7ba0deb38c94808c13a3e4c717f07bc3b9c866670e8d1" "2ff9ac386eac4dffd77a33e93b0c8236bb376c5a5df62e36d4bfa821d56e4e20" "1d609285d297920b97b0d230360a8d7c3f930edcf1abe96a1d82356f9a5e228d" "abe5ee8858cd1fbe36304a8c3b2315d3e0a4ef7c8588fcc45d1c23eafb725bb6" "d600c677f1777c1e4bfb066529b5b73c0179d0499dd4ffa3f599a0fb0cfbd501" "30289fa8d502f71a392f40a0941a83842152a68c54ad69e0638ef52f04777a4c" "c7f10959cb1bc7a36ee355c765a1768d48929ec55dde137da51077ac7f899521" "773e0bfa5450c75d613cbf29734cdc876c3d59dbf85b93cff3015a8687dea158" "bf798e9e8ff00d4bf2512597f36e5a135ce48e477ce88a0764cfb5d8104e8163" "1436d643b98844555d56c59c74004eb158dc85fc55d2e7205f8d9b8c860e177f" "1e9001d2f6ffb095eafd9514b4d5974b720b275143fbc89ea046495a99c940b0" "f11e219c9d043cbd5f4b2e01713c2c24a948a98bed48828dc670bd64ae771aa1" "8f97d5ec8a774485296e366fdde6ff5589cf9e319a584b845b6f7fa788c9fa9a" "2642a1b7f53b9bb34c7f1e032d2098c852811ec2881eec2dc8cc07be004e45a0" "5111a41453244802afd93eed1a434e612a8afbdf19c52384dffab129258bab6e" "0329c772ed96053a73b9ddddf96c1183e23c267955bbdf78e7933057ce9da04b" "36ca8f60565af20ef4f30783aa16a26d96c02df7b4e54e9900a5138fb33808da" "23b564cfb74d784c73167d7de1b9a067bcca00719f81e46d09ee71a12ef7ee82" "f7ef6451d988d6e2fc86deea398eee02b3371703d88f265d31a011bd240dcf99" "3d4df186126c347e002c8366d32016948068d2e9198c496093a96775cc3b3eaa" "c560237b7505f67a271def31c706151afd7aa6eba9f69af77ec05bde5408dbcd" "24cb0b5666e1e17fb6a378c413682f57fe176775eda015eb0a98d65fbb64b127" "b0eb9e6e6dcb29c6ec4bcd72605188f482d52ee019cb0ccc73b5404be4f3a6e7" "08a89acffece58825e75479333109e01438650d27661b29212e6560070b156cf" "c9ddf33b383e74dac7690255dd2c3dfa1961a8e8a1d20e401c6572febef61045" "a22f40b63f9bc0a69ebc8ba4fbc6b452a4e3f84b80590ba0a92b4ff599e53ad0" "585942bb24cab2d4b2f74977ac3ba6ddbd888e3776b9d2f993c5704aa8bb4739" "fa2af0c40576f3bde32290d7f4e7aa865eb6bf7ebe31eb9e37c32aa6f4ae8d10" "85d1dbf2fc0e5d30f236712b831fb24faf6052f3114964fdeadede8e1b329832" "bffb799032a7404b33e431e6a1c46dc0ca62f54fdd20744a35a57c3f78586646" "779df25c6240f183dd378811465566082eacc3c86ed260835382cb5c1dc54de3" "eee70baee3a2d093a98fa344480d2330eb3a17f8dfa883cc41d8008cd46fa669" "b70474b8a631f73868f01fdb047f102dd36325ecbf6789962e613e9195e165d7" "ccdd152be99a9250f5c24e09860911ff4b1519a8c4c73e4d67364514a3359f71" "ba913d12adb68e9dadf1f43e6afa8e46c4822bb96a289d5bf1204344064f041e" "146614f131e5029df850a268aff1f0e3ae16734a119904eab133755b574da37d" "c8935cb969e24ff30a6ee1da011eadc156b9f128a3b0a39cc664628838a644ad" "767a6105de48707dd6a593b62c05a7bf4ee9930c86e3225410110d95906772d6" "39546362fed4d5201b2b386dc21f21439497c9eec5fee323d953b3e230e4083e" "2f4f50d98073c01038b518066840638455657dc91dd1a225286d573926f36914" "80ae3a89f1eca6fb94a525004f66b544e347c6f756aaafb728c7cdaef85ea1f5" "7b1a2c8ec90a30cc5d039db0e52f192a291f4c3655103cf669721f94028eac27" "bcd0237b2a5b7897e482458cc62c4f3fa3d9d7f9a9667338e67d4c7a8e009819" "8e79884e89740cf6b7e0210f52e4ac995dc1f1a9a17151bfcfb4d660757a011b" "454c1c9ce70f7d807c51c890910365fd3c64a9e63f596511e9ff57dd97bbeea8" "387b487737860e18cbb92d83a42616a67c1edfd0664d521940e7fbf049c315ae" "6231254e74298a1cf8a5fee7ca64352943de4b495e615c449e9bb27e2ccae709" "3577ee091e1d318c49889574a31175970472f6f182a9789f1a3e9e4513641d86" "cbd85ab34afb47003fa7f814a462c24affb1de81ebf172b78cb4e65186ba59d2" "8f5b54bf6a36fe1c138219960dd324aad8ab1f62f543bed73ef5ad60956e36ae" "9d8ad1c413fccc14d992f6bed0ead11f1798a05ee8913daaa24a24604c212b61" "e246ff6951678c835ab95aedb99a48fdd665656eadf8b8bc0a4f60e17fbc6b7e" "e57eec7e0399272aaca7985a5cc94f3a2675db4cd2dbd79a99c72786e489e43c" "d0fd069415ef23ccc21ccb0e54d93bdbb996a6cce48ffce7f810826bb243502c" "ffba0482d3548c9494e84c1324d527f73ea4e43fff8dfd0e48faa8fc6d5c2bc7" "9e816bc85b64963710efdbc57db8545b53f7f359b0736e0b36fbc9efe07f12f4" "6ac7c0f959f0d7853915012e78ff70150bfbe2a69a1b703c3ac4184f9ae3ae02" "845103fcb9b091b0958171653a4413ccfad35552bc39697d448941bcbe5a660d" "bc836bf29eab22d7e5b4c142d201bcce351806b7c1f94955ccafab8ce5b20208" "7f6d4aebcc44c264a64e714c3d9d1e903284305fd7e319e7cb73345a9994f5ef" "10a31b6c251640d04b2fa74bd2c05aaaee915cbca6501bcc82820cdc177f5a93" "6e933f1668e124ec17fc7b6547f65ba760e06efb568a6c8091c600c67827e592" "02199888a97767d7779269a39ba2e641d77661b31b3b8dd494b1a7250d1c8dc1" "2a49f95b19d5926d940db11057077df2d01faaf33e66c5a8d4ee8043a904695f" "bdb4509c123230a059d89fc837c40defdecee8279c741b7f060196b343b2d18d" "ed17fef69db375ae1ced71fdc12e543448827aac5eb7166d2fd05f4c95a7be71" "6515fcc302292f29a94f6ac0c5795c57a396127d5ea31f37fc5f9f0308bbe19f" "5a45c8bf60607dfa077b3e23edfb8df0f37c4759356682adf7ab762ba6b10600" "6c5a5c47749e7992b4da3011595f5470f33e19f29b10564cd4f62faebbe36b91" "8a379e7ac3a57e64de672dd744d4730b3bdb88ae328e8106f95cd81cbd44e0b6" "2035a16494e06636134de6d572ec47c30e26c3447eafeb6d3a9e8aee73732396" "ed0b4fc082715fc1d6a547650752cd8ec76c400ef72eb159543db1770a27caa7" "42b9d85321f5a152a6aef0cc8173e701f572175d6711361955ecfb4943fe93af" "021720af46e6e78e2be7875b2b5b05344f4e21fad70d17af7acfd6922386b61e" "9fcac3986e3550baac55dc6175195a4c7537e8aa082043dcbe3f93f548a3a1e0" "242527ce24b140d304381952aa7a081179a9848d734446d913ca8ef0af3cef21" "8cb818e0658f6cc59928a8f2b2917adc36d882267bf816994e00c5b8fcbf6933" "3fa81193ab414a4d54cde427c2662337c2cab5dd4eb17ffff0d90bca97581eb6" "44247f2a14c661d96d2bff302f1dbf37ebe7616935e4682102b68c0b6cc80095" "73bff6f2ef60f8a1238a9ca666235d258e3acdeeed85d092ca532788dd7a33c4" "05eeb814f74b2fd4f2e6e37b4d604eb9b1daaaedfa5e692f1d485250c6b553eb" "0055e55e6a357a941027139152a67f93376616d3501055d06852f10fdc16bac0" "1f3113447a652b8436a9938bbac71ecaf022cc73ecd0d76182eb9713aa781f17" "b755c709cb46ba4599ab3a3c189a056e9736cbbb39ed9ecfc1ab1aa3d6f79021" "75c5c39809c52d48cb9dcbf1694bf2d27d5f6fd053777c194e0b69d8e49031c0" "54e08527b4f4b127ebf7359acbbbecfab55152da01716c4809682eb71937fd33" "81db42d019a738d388596533bd1b5d66aef3663842172f3696733c0aab05a150" "ef1e992ef341e86397b39ee6b41c1368e1b33d45b0848feac6a8e8d5753daa67" "ad109c1ad8115573f40e22ac2b996693b5d48052fa37b5919f70ea37c62a965e" "b143ad150e25f9b6d09ae313718f85cc785c89445f3369f74bd0d836d5881c56" "dc9a8d70c4f94a28aafc7833f8d05667601968e6c9bf998791c39fcb3e4679c9" "125fd2180e880802ae98b85f282b17f0aa8fa6cb9fc4f33d7fb19a38c40acef0" "4d80487632a0a5a72737a7fc690f1f30266668211b17ba836602a8da890c2118" "9a155066ec746201156bb39f7518c1828a73d67742e11271e4f24b7b178c4710" "4bfced46dcfc40c45b076a1758ca106a947b1b6a6ff79a3281f3accacfb3243c" "31992d4488dba5b28ddb0c16914bf5726dc41588c2b1c1a2fd16516ea92c1d8e" "0e33022384e4db1374827f51e3d9e9a2d56282c2e3568c22f1c12ad80e20cf0c" "83db918b06f0b1df1153f21c0d47250556c7ffb5b5e6906d21749f41737babb7" "47744f6c8133824bdd104acc4280dbed4b34b85faa05ac2600f716b0226fb3f6" "8b313e1793da427e90c034dbe74f3ad9092ac291846c0f855908c42a6bda1ff4" "43c1a8090ed19ab3c0b1490ce412f78f157d69a29828aa977dae941b994b4147" "bc4b650c41b16b98166b35da94b366c6a9e1e7883bbf4937c897fb7bd05aa619" "e9460a84d876da407d9e6accf9ceba453e2f86f8b86076f37c08ad155de8223c" "8ec2e01474ad56ee33bc0534bdbe7842eea74dccfb576e09f99ef89a705f5501" "d606ac41cdd7054841941455c0151c54f8bff7e4e050255dbd4ae4d60ab640c1" "4f2ede02b3324c2f788f4e0bad77f7ebc1874eff7971d2a2c9b9724a50fb3f65" "2b6bd2ebad907ee42b3ffefa4831f348e3652ea8245570cdda67f0034f07db93" "7f3ef7724515515443f961ef87fee655750512473b1f5bf890e2dc7e065f240c" "65d9573b64ec94844f95e6055fe7a82451215f551c45275ca5b78653d505bc42" "39dffaee0e575731c909bb3e4b411f1c4759c3d7510bf02aa5aef322a596dd57" "2cf7f9d1d8e4d735ba53facdc3c6f3271086b6906c4165b12e4fd8e3865469a6" default))

 '(inferior-lisp-program "clasp" t)

 '(inferior-lisp-program "sbcl" t)

   '(outshine meow pikchr-mode ement fennel-mode ox-gemini omtose-phellack-theme pyvenv-auto paredit warm-night-theme geiser-guile geiser geiser-chicken spacegray-theme soft-charcoal-theme slime abyss-theme ample-theme djvu elpher ox-rst ripgrep unicode-fonts no-spam uuid marginalia embark-consult embark orderless selectrum consult vertico dockerfile-mode x509-mode forth-mode browse-at-remote cider sesman clojure-mode eziam-theme scad-mode acme-theme sexy-monochrome-theme monotropic-theme constant-theme graphviz-dot-mode mood-line mood-one-theme modus-vivendi-theme modus-operandi-theme browse-url-dwim magit parchment-theme almost-mono-themes borland-blue-theme nordless-theme northcode-theme nord-theme nofrils-acme-theme multikeyfreq fireplace boon csv-mode ein markdown-mode puppet-mode dad-joke keyfreq avy-zap avy ggtags counsel-projectile projectile command-log-mode counsel vc-fossil visible-mark esup sudden-death jammer arjen-grey-theme atom-dark-theme clues-theme dark-krystal-theme darkburn-theme eink-theme foggy-night-theme green-screen-theme gruvbox-theme heroku-theme inverse-acme-theme iodine-theme labburn-theme leuven-theme evil-visual-mark-mode excorporate telephone-line xah-fly-keys which-key url-http-ntlm toml-mode plan9-theme ergoemacs-mode))

   '(caml mastodon emacs-gc-stats outshine meow pikchr-mode ement fennel-mode ox-gemini omtose-phellack-theme pyvenv-auto paredit warm-night-theme geiser-guile geiser geiser-chicken spacegray-theme soft-charcoal-theme slime abyss-theme ample-theme djvu elpher ox-rst ripgrep unicode-fonts no-spam uuid marginalia embark-consult embark orderless selectrum consult vertico dockerfile-mode x509-mode forth-mode browse-at-remote cider sesman clojure-mode eziam-theme scad-mode acme-theme sexy-monochrome-theme monotropic-theme constant-theme graphviz-dot-mode mood-line mood-one-theme modus-vivendi-theme modus-operandi-theme browse-url-dwim magit parchment-theme almost-mono-themes borland-blue-theme nordless-theme northcode-theme nord-theme nofrils-acme-theme multikeyfreq fireplace boon csv-mode ein markdown-mode puppet-mode dad-joke keyfreq avy-zap avy ggtags counsel-projectile projectile command-log-mode counsel vc-fossil visible-mark esup sudden-death jammer arjen-grey-theme atom-dark-theme clues-theme dark-krystal-theme darkburn-theme eink-theme foggy-night-theme green-screen-theme gruvbox-theme heroku-theme inverse-acme-theme iodine-theme labburn-theme leuven-theme evil-visual-mark-mode excorporate telephone-line xah-fly-keys which-key url-http-ntlm toml-mode plan9-theme ergoemacs-mode))

;; unassociate .ml files with lisp: i edit ocaml source
(setq auto-mode-alist (cons '("\\.ml\\'" . caml-mode) (assoc-delete-all ".ml" auto-mode-alist #'string-match)))

(setq mastodon-instance-url "https://emacs.ch"
      mastodon-active-user "jaredj")

;;; ts.el --- Timestamp and date/time library  -*- lexical-binding: t; -*-
;; Copyright (C) 2018-2019 Adam Porter
;; Author: Adam Porter <adam@alphapapa.net>
;; URL: http://github.com/alphapapa/ts.el
;; Version: 0.3
;; Package-Requires: ((emacs "26.1") (dash "2.14.1") (s "1.12.0"))
;; Keywords: calendar, lisp
;; This file is not part of GNU Emacs.
;;; Commentary:
;; This package is designed to ease manipulation of dates, times, and
;; timestamps in Emacs.
;; A struct `ts' is defined, which represents a timestamp.  All
;; manipulation is done internally using Unix timestamps.  Accessors
;; are used to retrieve calendar values such as month, day, year from
;; a timestamp, and these values are cached in the struct once
;; accessed, to avoid repeatedly calling `format-time-string', which
;; is expensive.  Function arguments are designed to work well with
;; the `thread-last' macro, to make sequential operations easy to
;; follow.
;; The current timestamp is retrieved with `ts-now'.
;; Timestamps are easily modified using `ts-adjust', `ts-apply',
;; `ts-incf', `ts-dec', etc.
;; Timestamps are parsed and formatted using `ts-parse',
;; `ts-parse-org', and `ts-format'.
;; Differences and durations are calculated with `ts-diff',
;; `ts-human-duration', and `ts-human-format-duration'.  Comparisons
;; are done with `ts<', `ts<=', `ts=', `ts>', and `ts>='.
;;; License:
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
;;; Code:
;;;; Requirements
(require 'cl-lib)
(require 'dash)
(require 's)
;;;; Variables
(defvar ts-default-format "%Y-%m-%d %H:%M:%S %z"
  "Default format for `ts-format'.")
;;;; Structs
(cl-defmacro ts-defstruct (&rest args)
  "Like `cl-defstruct', but with additional slot options from ARGS.
Additional slot options and values:
`:accessor-init': a sexp that initializes the slot in the
accessor if the slot is nil.  The symbol `struct' will be bound
to the current struct.  The accessor is defined after the struct
is fully defined, so it may refer to the struct
definition (e.g. by using the `cl-struct' `pcase' macro).
`:aliases': A list of symbols which will be aliased to the slot
accessor, prepended with the struct name (e.g. a struct `ts' with
slot `year' and alias `y' would create an alias `ts-y')."
  (declare (indent defun))
  ;; FIXME: Compiler warnings about accessors defined multiple times.  Not sure if we can fix this
  ;; except by ignoring warnings.
  (let* ((struct-name (car args))
         (struct-slots (cdr args))
         (cl-defstruct-expansion (macroexpand `(cl-defstruct ,struct-name ,@struct-slots)))
         accessor-forms alias-forms)
    (cl-loop for slot in struct-slots
             for pos from 1
             when (listp slot)
             do (-let* (((slot-name _slot-default . slot-options) slot)
                        ((&keys :accessor-init :aliases) slot-options)
                        (accessor-name (intern (concat (symbol-name struct-name) "-" (symbol-name slot-name))))
                        (accessor-docstring (format "Access slot \"%s\" of `%s' struct STRUCT."
                                                    slot-name struct-name))
                        (struct-pred (intern (concat (symbol-name struct-name) "-p")))
                        ;; Accessor form copied from macro expansion of `cl-defstruct'.
                        (accessor-form `(cl-defsubst ,accessor-name (struct)
                                          ,accessor-docstring
                                          ;; FIXME: side-effect-free is probably not true here, but what about error-free?
                                          ;;  (declare (side-effect-free error-free))
                                          (or (,struct-pred struct)
                                              (signal 'wrong-type-argument
                                                      (list ',struct-name struct)))
                                          ,(when accessor-init
                                             `(unless (aref struct ,pos)
                                                (aset struct ,pos ,accessor-init)))
                                          ;; NOTE: It's essential that this `aref' form be last
                                          ;; so the gv-setter works in the compiler macro.
                                          (aref struct ,pos))))
                  (push accessor-form accessor-forms)
                  ;; Remove accessor forms from `cl-defstruct' expansion.  This may be distasteful,
                  ;; but it would seem more distasteful to copy all of `cl-defstruct' and potentially
                  ;; have the implementations diverge in the future when Emacs changes (e.g. the new
                  ;; record type).
                  (cl-loop for form in-ref cl-defstruct-expansion
                           do (pcase form
                                (`(cl-defsubst ,(and accessor (guard (eq accessor accessor-name)))
                                      . ,_)
                                 accessor  ; Silence "unused lexical variable" warning.
                                 (setf form nil))))
                  ;; Alias definitions.
                  (cl-loop for alias in aliases
                           for alias-name = (intern (concat (symbol-name struct-name) "-" (symbol-name alias)))
                           do (push `(defalias ',alias-name ',accessor-name) alias-forms))
                  ;; TODO: Setter
                  ;; ,(when (plist-get slot-options :reset)
                  ;;    `(gv-define-setter ,accessor-name (ts value)
                  ;;       `(progn
                  ;;          (aset ,ts ,,pos ,value)
                  ;;          (setf (ts-unix ts) ni))))
                  ))
    `(progn
       ,cl-defstruct-expansion
       ,@accessor-forms
       ,@alias-forms)))
;; TODO: When a field is changed, the unix/internal slot needs to be updated.  On the other hand,
;; maybe not.  Maybe `ts-adjust' should be the only way to adjust them.  Otherwise, updating the
;; unix/internal time value when a slot is changed gets really complicated, and it might not be
;; worth it.  Or, at least, not in the initial version.
(ts-defstruct ts
  (hour
   nil :accessor-init (string-to-number (format-time-string "%H" (ts-unix struct)))
   :aliases (H)
   :constructor "%H"
   :type integer)
  (minute
   nil :accessor-init (string-to-number (format-time-string "%M" (ts-unix struct)))
   :aliases (min M)
   :constructor "%M"
   :type integer)
  (second
   nil :accessor-init (string-to-number (format-time-string "%S" (ts-unix struct)))
   :aliases (sec S)
   :constructor "%S"
   :type integer)
  (day
   nil :accessor-init (string-to-number (format-time-string "%d" (ts-unix struct)))
   :aliases (day-of-month-num dom d)
   :constructor "%d"
   :type integer)
  (month
   nil :accessor-init (string-to-number (format-time-string "%m" (ts-unix struct)))
   :aliases (month-num moy m)
   :constructor "%m"
   :type integer)
  (year
   nil :accessor-init (string-to-number (format-time-string "%Y" (ts-unix struct)))
   :aliases (Y)
   :constructor "%Y"
   :type integer)
  (dow
   nil :accessor-init (string-to-number (format-time-string "%w" (ts-unix struct)))
   :aliases (day-of-week-num)
   :constructor "%w"
   :type integer)
  (day-abbr
   nil :accessor-init (format-time-string "%a" (ts-unix struct))
   :aliases (day-of-week-abbr)
   :constructor "%a")
  (day-name
   nil :accessor-init (format-time-string "%A" (ts-unix struct))
   :aliases (day-of-week-name)
   :constructor "%A")
  ;; (doe nil
  ;;      :accessor-init (days-between (format-time-string "%Y-%m-%d 00:00:00" (ts-unix struct))
  ;;                                   "1970-01-01 00:00:00")
  ;;      :aliases (day-of-epoch))
  (doy
   nil :accessor-init (string-to-number (format-time-string "%j" (ts-unix struct)))
   :aliases (day-of-year)
   :constructor "%j"
   :type integer)
  (woy
   nil :accessor-init (string-to-number (format-time-string "%V" (ts-unix struct)))
   :aliases (week week-of-year)
   :constructor "%V"
   :type integer)
  (month-abbr
   nil :accessor-init (format-time-string "%b" (ts-unix struct))
   :aliases (b)
   :constructor "%b")
  (month-name
   nil :accessor-init (format-time-string "%B" (ts-unix struct))
   :aliases (B)
   :constructor "%B")
  (tz-abbr
   nil :accessor-init (format-time-string "%Z" (ts-unix struct))
   :constructor "%Z")
  (tz-offset
   nil :accessor-init (format-time-string "%z" (ts-unix struct))
   :constructor "%z")
  ;; MAYBE: Add tz-offset-minutes
  (internal
   nil :accessor-init (apply #'encode-time (decode-time (ts-unix struct))))
  (unix
   nil :accessor-init (pcase-let* (((cl-struct ts second minute hour day month year) struct))
                        (if (and second minute hour day month year)
                            (float-time (encode-time second minute hour day month year))
                          (float-time)))))
;;;; Substs
(defun ts-now ()
  "Return `ts' struct set to now.
This is a non-inlined function, so it may be rebound, e.g. with
`cl-letf' for testing."
  (make-ts :unix (float-time)))
(defsubst ts-format (&optional ts-or-format-string ts)
  "Format timestamp with `format-time-string'.
If TS-OR-FORMAT-STRING is a timestamp or nil, use the value of
`ts-default-format'.  If both TS-OR-FORMAT-STRING and TS are nil,
use the current time."
  (cl-etypecase ts-or-format-string
    (ts (format-time-string ts-default-format (ts-unix ts-or-format-string)))
    (string (cl-etypecase ts
              (ts (format-time-string ts-or-format-string (ts-unix ts)))
              (null (format-time-string ts-or-format-string))))
    (null (cl-etypecase ts
            (ts (format-time-string ts-default-format (ts-unix ts)))
            (null (format-time-string ts-default-format))))))
(defsubst ts-parse (string)
  "Return new `ts' struct, parsing STRING with `parse-time-string'."
  (let ((parsed (parse-time-string string)))
    ;; Fill nil values
    (cl-loop for i from 0 to 5
             when (null (nth i parsed))
             do (setf (nth i parsed) 0))
    (->> parsed
         (apply #'encode-time)
         float-time
         (make-ts :unix))))
(defsubst ts-parse-fill (fill string)
  "Return new `ts' struct, parsing STRING with `parse-time-string'.
Empty hour/minute/second values are filled according to FILL: if
`begin', with 0; if `end', hour is filled with 23 and
minute/second with 59; if nil, an error may be signaled when time
values are empty.
Note that when FILL is `end', a time value like \"12:12\" is
filled to \"12:12:00\", not \"12:12:59\"."
  (let ((parsed (parse-time-string string)))
    ;; Fill nil values
    (pcase-exhaustive fill
      ('begin (unless (nth 0 parsed)
                (setf (nth 0 parsed) 0))
              (unless (nth 1 parsed)
                (setf (nth 1 parsed) 0))
              (unless (nth 2 parsed)
                (setf (nth 2 parsed) 0)))
      ;; NOTE: When the second value is not present in the string, it's
      ;; set to 0, even when FILL is `end'.  In a way this seems wrong,
      ;; but on the other hand, "12:12" as a plain time value is assumed
      ;; to refer to the moment it becomes 12:12, which means 0 seconds.
      ('end (unless (nth 0 parsed)
              (setf (nth 0 parsed) 59))
            (unless (nth 1 parsed)
              (setf (nth 1 parsed) 59))
            (unless (nth 2 parsed)
              (setf (nth 2 parsed) 23)))
      (`nil nil))
    (->> parsed
         (apply #'encode-time)
         float-time
         (make-ts :unix))))
(defsubst ts-reset (ts)
  "Return TS with all slots cleared except `unix'.
Non-destructive.  The same as:
    (make-ts :unix (ts-unix ts))"
  (make-ts :unix (ts-unix ts)))
(defsubst ts-update (ts)
  "Return timestamp TS after updating its Unix timestamp from its other slots.
Non-destructive.  To be used after setting slots with,
e.g. `ts-fill'."
  (pcase-let* (((cl-struct ts second minute hour day month year) ts))
    (make-ts :unix (float-time (encode-time second minute hour day month year)))))
(defsubst ts-parse-org-element (element)
  "Return timestamp object for Org timestamp element ELEMENT.
Element should be like one parsed by `org-element', the first
element of which is `timestamp'.  Assumes timestamp is not a
range."
  (-let (((_ (&keys :year-start :month-start :day-start :hour-start :minute-start)) element))
    (make-ts :year year-start :month month-start :day day-start
             :hour (or hour-start 0) :minute (or minute-start 0) :second 0)))
;; We don't want to force `org' to load when this library does, so we declare
;; the function.  Users should load `org' before calling `ts-parse-org'.
(declare-function org-parse-time-string "org-macs.el")
(defsubst ts-parse-org (org-ts-string)
  "Return timestamp object for Org timestamp string ORG-TS-STRING.
Note that function `org-parse-time-string' is called, which
should be loaded before calling this function."
  (pcase-let* ((`(,second ,minute ,hour ,day ,month ,year)
                (save-match-data
                  (org-parse-time-string org-ts-string))))
    (make-ts :second second :minute minute :hour hour :day day :month month :year year)))
(defsubst ts-parse-org-fill (fill org-ts-string)
  "Return timestamp object for Org timestamp string ORG-TS-STRING.
Note that function `org-parse-time-string' is called, which
should be loaded before calling this function.
Hour/minute/second values are filled according to FILL: if
`begin', with 0; if `end', hour is filled with 23 and
minute/second with 59.  Note that `org-parse-time-string' does
not support timestamps that contain seconds."
  (pcase-let* ((`(,second ,minute ,hour ,day ,month ,year)
                (org-parse-time-string org-ts-string 'nodefault)))
    (pcase-exhaustive fill
      ('begin (unless second
                (setf second 0))
              (unless minute
                (setf minute 0))
              (unless hour
                (setf hour 0)))
      ('end (if (not (or hour minute))
                (progn
                  ;; `hour' and `minute' are nil, so set them and `second'.
                  ;; `org-parse-time-string' sets the second to 0 even if
                  ;; NODEFAULT is non-nil.
                  (setf second 59
                        minute 59
                        hour 23))
              ;; FIXME: Some of these could be omitted.
              (unless second
                (setf second 59))
              (unless minute
                (setf minute 59))
              (unless hour
                (setf hour 23))))
      (_ (error "FILL must be `begin' or `end'")))
    (make-ts :second second :minute minute :hour hour :day day :month month :year year)))
;;;; Functions
(cl-defun ts-apply (&rest args)
  "Return new timestamp based on TS with new slot values from ARGS.
Fill timestamp slots, overwrite given slot values, and return new
timestamp with Unix timestamp value derived from new slot values.
SLOTS is a list of alternating key-value pairs like that passed
to `make-ts'."
  (declare (advertised-calling-convention (&rest slots ts) nil))
  (-let* (((&keys :second :minute :hour :day :month :year) args)
          (ts (-last-item args)))
    ;; MAYBE: Add timezone offset?
    (setf ts (ts-fill ts))
    (when second
      (setf (ts-second ts) second))
    (when minute
      (setf (ts-minute ts) minute))
    (when hour
      (setf (ts-hour ts) hour))
    (when day
      (setf (ts-day ts) day))
    (when month
      (setf (ts-month ts) month))
    (when year
      (setf (ts-year ts) year))
    (ts-update ts)))
(defmacro ts-define-fill ()
  "Define function that fills all applicable slots of a `ts' from its `unix' slot."
  (let* ((slots (->> (cl-struct-slot-info 'ts)
                     (--select (and (not (member (car it) '(unix internal cl-tag-slot)))
                                    (plist-get (cddr it) :constructor)))
                     (--map (list (intern (concat ":" (symbol-name (car it))))
                                  (cddr it)))))
         (keywords (-map #'car slots))
         (constructors (->> slots
                            (--map (plist-get (cadr it) :constructor))
                            -non-nil))
         (types (--map (plist-get (cadr it) :type) slots))
         (format-string (s-join "\f" constructors))
         (value-conversions (cl-loop for type in types
                                     for keyword in keywords
                                     for i from 0
                                     for val = `(nth ,i time-values)
                                     append (list keyword (pcase type
                                                            ('integer `(string-to-number ,val))
                                                            (_ val))))))
    ;; MAYBE: Construct the record manually?  Probably not worth it, but might eke out a bit more speed.
    `(defun ts-fill (ts &optional zone)
       "Return TS having filled all slots from its Unix timestamp.
This is non-destructive.  ZONE is passed to `format-time-string',
which see."
       ;; MAYBE: Use `decode-time' instead of `format-time-string'?  It provides most of the values we need.  Should benchmark.
       (let ((time-values (save-match-data
                            (split-string (format-time-string ,format-string (ts-unix ts) zone) "\f"))))
         (make-ts :unix (ts-unix ts) ,@value-conversions)))))
(ts-define-fill)
;; FIXME: This fails, and I'm not sure if it's a limitation of gvs or if I did something wrong:
;;   (ts-incf (ts-moy (ts-now)))
(defun ts-difference (a b)
  "Return difference in seconds between timestamps A and B."
  ;; MAYBE: Use absolute values so arg order doesn't matter.
  (- (ts-unix a) (ts-unix b)))
(defalias 'ts-diff 'ts-difference)
(defun ts-human-duration (seconds)
  "Return plist describing duration SECONDS.
List includes years, days, hours, minutes, and seconds.  This is
a simple calculation that does not account for leap years, leap
seconds, etc."
  ;; TODO: Add weeks.
  (cl-macrolet ((dividef (place divisor)
                         ;; Divide PLACE by DIVISOR, set PLACE to the remainder, and return the quotient.
                         `(prog1 (/ ,place ,divisor)
                            (setf ,place (% ,place ,divisor)))))
    (let* ((seconds (floor seconds))
           (years (dividef seconds 31536000))
           (days (dividef seconds 86400))
           (hours (dividef seconds 3600))
           (minutes (dividef seconds 60)))
      (list :years years :days days :hours hours :minutes minutes :seconds seconds))))
;; See also the built-in function `format-seconds', which I seem to have
;; overlooked before writing this.  However, a quick benchmark, run
;; 100,000 times, shows that, when controllable formatting is not needed,
;; `ts-human-format-duration' is much faster and generates less garbage:
;; | Form                     | x faster than next | Total runtime | # of GCs | Total GC runtime |
;; |--------------------------+--------------------+---------------+----------+------------------|
;; | ts-human-format-duration | 5.82               |      0.832945 |        3 |         0.574929 |
;; | format-seconds           | slowest            |      4.848253 |       17 |         3.288799 |
(cl-defun ts-human-format-duration (seconds &optional abbreviate)
  "Return human-formatted string describing duration SECONDS.
If SECONDS is less than 1, returns \"0 seconds\".  If ABBREVIATE
is non-nil, return a shorter version, without spaces.  This is a
simple calculation that does not account for leap years, leap
seconds, etc."
  ;; FIXME: Doesn't work with negative values, even though `ts-human-duration' does.
  (if (< seconds 1)
      (if abbreviate "0s" "0 seconds")
    (cl-macrolet ((format> (place)
                           ;; When PLACE is greater than 0, return formatted string using its symbol name.
                           `(when (> ,place 0)
                              (format "%d%s%s" ,place
                                      (if abbreviate "" " ")
                                      (if abbreviate
                                          ,(substring (symbol-name place) 0 1)
                                        ,(symbol-name place)))))
                  (join-places (&rest places)
                               ;; Return string joining the names and values of PLACES.
                               `(->> (list ,@(cl-loop for place in places
                                                      collect `(format> ,place)))
                                     -non-nil
                                     (s-join (if abbreviate "" ", ")))))
      (-let* (((&plist :years :days :hours :minutes :seconds) (ts-human-duration seconds)))
        (join-places years days hours minutes seconds)))))
;;;;; Adjustors
;; These functions are very cool, and they may make the adjust function unnecessary, because you can
;; do something like (ts-adjust 'moy 120 (ts-now)) and get a timestamp 10 years in the future.
;; FIXME: Note that not all slots can be used to adjust the timestamp.
;; For example, the day-of-week-num slot doesn't have any effect.
;;;;;; Non-destructive
;; These non-destructive versions take the slot symbol as an argument and the object last, and they
;; return the timestamp object rather than the new slot value, making them suitable for use in
;; threading macros when the initial form is a sexp rather than a value or variable.
(defun ts-adjust (&rest adjustments)
  "Return new timestamp having applied ADJUSTMENTS to TS.
ADJUSTMENTS should be a series of alternating SLOTS and VALUES by
which to adjust them.  For example, this form returns a new
timestamp that is 47 hours into the future:
  (ts-adjust 'hour -1 'day +2 (ts-now))
Since the timestamp argument is last, it's suitable for use in a
threading macro."
  (declare (advertised-calling-convention (&rest adjustments ts) nil))
  (let* ((ts (-last-item adjustments))
         (adjustments (nbutlast adjustments))
         (ts (ts-fill ts)))
    (cl-loop for (slot change) on adjustments by #'cddr
             do (cl-incf (cl-struct-slot-value 'ts slot ts) change))
    (ts-update ts)))
(defsubst ts-inc (slot value ts)
  "Return a new timestamp based on TS with its SLOT incremented by VALUE.
SLOT should be specified as a plain symbol, not a keyword."
  (setq ts (ts-fill ts))
  (cl-incf (cl-struct-slot-value 'ts slot ts) value)
  (ts-update ts))
(defsubst ts-dec (slot value ts)
  "Return a new timestamp based on TS with its SLOT decremented by VALUE.
SLOT should be specified as a plain symbol, not a keyword."
  (setq ts (ts-fill ts))
  (cl-decf (cl-struct-slot-value 'ts slot ts) value)
  (ts-update ts))
;;;;;; Generalized variables
;; These destructive versions act like `cl-incf'.  They are slightly less suitable for use in
;; threading macros, because it's not possible to do, e.g. this:
;;   (-> (ts-now)
;;       (ts-adjustf 'day 1))
;; ...because `ts-now' doesn't return a generalized variable.  But this still works:
;;   (let ((ts (ts-now)))
;;     (-> ts (ts-adjustf 'dom 1)))
;;  TODO: Look at `cl-incf' implementation, consider whether we should imitate it.
(defmacro ts-adjustf (ts &rest adjustments)
  "Return timestamp TS having applied ADJUSTMENTS.
This function is destructive, as it calls `setf' on TS.
ADJUSTMENTS should be a series of alternating SLOTS and VALUES by
which to adjust them.  For example, this form adjusts a timestamp
to 47 hours into the future:
  (let ((ts (ts-now)))
    (ts-adjustf ts 'hour -1 'day +2))"
  ;; MAYBE: Is it possible to make this kind of macro work in a threading macro by taking its TS
  ;; argument last?  It only seems to work if the TS is a symbol rather than a form, because of how
  ;; generalized variables work, but that makes it less useful and more error-prone.
  `(progn
     ;; We use the accessor functions rather than `cl-struct-slot-value', because it's slightly
     ;; faster to use the accessors, even though `cl-struct-slot-value' is supposed to be
     ;; byte-compiled to essentially the same thing (although it's possible I'm doing something
     ;; wrong).
     (setf ,ts (ts-fill ,ts))
     ,@(cl-loop for (slot change) on adjustments by #'cddr
                for accessor = (intern (concat "ts-" (symbol-name (cadr slot))))
                collect `(cl-incf (,accessor ,ts) ,change))
     (setf ,ts (ts-update ,ts))))
(cl-defmacro ts-incf (place &optional (value 1))
  "Increment `ts' PLACE by VALUE (default 1) and return the new value of PLACE.
Updates its `unix' slot accordingly."
  `(progn
     (setf ,(cadr place) (ts-fill ,(cadr place)))
     (prog1
         (cl-incf ,place ,value)
       (setf ,(cadr place)
             (ts-update ,(cadr place))))))
(cl-defmacro ts-decf (place &optional (value 1))
  "Decrement `ts' PLACE by VALUE (default 1) and return the new value of PLACE.
Updates its `unix' slot accordingly."
  `(progn
     (setf ,(cadr place) (ts-fill ,(cadr place)))
     (prog1
         (cl-decf ,place ,value)
       (setf ,(cadr place)
             (ts-update ,(cadr place))))))
;;;;; Comparators
(defsubst ts-in (beg end ts)
  "Return non-nil if TS is within range BEG to END, inclusive.
All arguments should be `ts' structs."
  (and (ts<= beg ts)
       (ts<= ts end)))
(defun ts= (a b)
  "Return non-nil if timestamp A is the same as timestamp B.
Compares only the timestamps' `unix' slots.  Note that a
timestamp's Unix slot is a float and may differ by less than one
second, causing them to be unequal even if all of the formatted
parts of the timestamp are the same."
  (= (ts-unix a) (ts-unix b)))
(defun ts< (a b)
  "Return non-nil if timestamp A is less than timestamp B."
  (< (ts-unix a) (ts-unix b)))
(defun ts<= (a b)
  "Return non-nil if timestamp A is <= timestamp B."
  (<= (ts-unix a) (ts-unix b)))
(defun ts> (a b)
  "Return non-nil if timestamp A is greater than timestamp B."
  (> (ts-unix a) (ts-unix b)))
(defun ts>= (a b)
  "Return non-nil if timestamp A is >= timestamp B."
  (>= (ts-unix a) (ts-unix b)))
;;;; Footer
(provide 'ts)
;;; ts.el ends here

(define-package "ts" "20220822.2313" "Timestamp and date/time library"
  '((emacs "26.1")
    (dash "2.14.1")
    (s "1.12.0"))
  :commit "552936017cfdec89f7fc20c254ae6b37c3f22c5b" :authors
  '(("Adam Porter" . "adam@alphapapa.net"))
  :maintainers
  '(("Adam Porter" . "adam@alphapapa.net"))
  :maintainer
  '("Adam Porter" . "adam@alphapapa.net")
  :keywords
  '("calendar" "lisp")
  :url "http://github.com/alphapapa/ts.el")
;; Local Variables:
;; no-byte-compile: t
;; End:

;;; ts-autoloads.el --- automatically extracted autoloads  -*- lexical-binding: t -*-
;;
;;; Code:
(add-to-list 'load-path (directory-file-name
                         (or (file-name-directory #$) (car load-path))))

;;;### (autoloads nil "ts" "ts.el" (0 0 0 0))
;;; Generated autoloads from ts.el
(register-definition-prefixes "ts" '("ts-" "ts<" "ts=" "ts>"))
;;;***

;;;### (autoloads nil nil ("ts-pkg.el") (0 0 0 0))
;;;***

;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; ts-autoloads.el ends here

Good signature from 066DAFCB81E42C40 GNU ELPA Signing Agent (2019) <elpasign@elpa.gnu.org> (trust undefined) created at 2022-09-13T17:10:02-0400 using RSA

(require 'persist)
(require 'seq)
(defmacro with-local-temp-persist (&rest body)
  (declare (debug body))
  `(unwind-protect
       (let ((persist--directory-location "./persist/")
             (persist--symbols nil))
         ,@body)
     (delete-directory "./persist" t)))
(ert-deftest test-persist-symbol ()
  (should
   (let ((persist--symbols nil)
         (sym (cl-gensym)))
     (persist-symbol sym 10)
     (seq-contains persist--symbols sym))))
(ert-deftest test-persist-save-only-persistant ()
  ;; do not save not persist variables
  (should-error
   (with-local-temp-persist
    (persist-save (cl-gensym)))
   :type 'error
   :exclude-subtypes t))
(ert-deftest test-persist-save ()
  (with-local-temp-persist
   (let ((sym (cl-gensym)))
     ;; precondition
   (should-not (file-exists-p (persist--file-location sym)))
     (set sym 10)
     (persist-symbol sym 10)
     (persist-save sym)
     (should t)
     (should-not (file-exists-p (persist--file-location sym)))
     (set sym 20)
     (persist-save sym)
     (should (file-exists-p (persist--file-location sym)))
     (should
      (string-match-p
       "20"
       (with-temp-buffer
         (insert-file-contents (persist--file-location sym))
         (buffer-string))))
     (set sym 10)
     (persist-save sym)
     (should-not (file-exists-p (persist--file-location sym)))
     (should-error
      (persist-save 'fred)))))
(ert-deftest test-persist-save-non-number ()
  "Test saving something that is not a number.
`test-persist-save' missed "
  (with-local-temp-persist
   (let ((sym (cl-gensym)))
     (set sym "fred")
     (persist-symbol sym "fred")
     (persist-save sym)
     (should t)
     (should-not (file-exists-p (persist--file-location sym)))
     (set sym "george")
     (persist-save sym)
     (should (file-exists-p (persist--file-location sym)))
     (should
      (string-match-p
       "george"
       (with-temp-buffer
         (insert-file-contents (persist--file-location sym))
         (buffer-string)))))))
(ert-deftest test-persist-load ()
  (with-local-temp-persist
   (let ((sym (cl-gensym)))
     (set sym 10)
     ;; set this different to force save
     (persist-symbol sym 1)
     (persist-save sym)
     (should (equal 10 (symbol-value sym)))
     (set sym 30)
     (should (equal 30 (symbol-value sym)))
     (persist-load sym)
     (should (equal 10 (symbol-value sym))))))
(ert-deftest test-persist-remove ()
  (with-local-temp-persist
   (let ((sym (cl-gensym)))
     (should-not (persist--persistant-p sym))
     (persist-symbol sym 10)
     (should (persist--persistant-p sym))
     (persist-unpersist sym)
     (should-not (persist--persistant-p sym)))))
(ert-deftest test-persist-defvar ()
  (with-local-temp-persist
   (defvar test-no-persist-variable 10 "docstring")
   (persist-defvar test-persist-variable 20 "docstring")
   (should-not (persist--persistant-p 'test-no-persist-variable))
   (should (persist--persistant-p 'test-persist-variable))
   (should (= 20
              (persist-default 'test-persist-variable)))))
(ert-deftest test-persist-location ()
  (unwind-protect
      (let ((sym (cl-gensym)))
        (delete-directory "./persist-defined-location" t)
        (set sym 10)
        (persist-symbol sym 10)
        (persist-location sym "./persist-defined-location")
        (should
         (equal (expand-file-name
                 (symbol-name sym)
                 "./persist-defined-location/")
                (persist--file-location sym)))
        (persist-save sym)
        (should-not (file-exists-p (persist--file-location sym)))
        (set sym 20)
        (persist-save sym)
        (should (file-exists-p (persist--file-location sym)))
        (should
         (string-match-p
          "20"
          (with-temp-buffer
            (insert-file-contents (persist--file-location sym))
            (buffer-string))))
        (should-error
         (persist-save 'fred)))
    (delete-directory "./persist-defined-location" t)))

\input texinfo
@setfilename persist.info
@settitle persist persistant variables
@dircategory Emacs
@direntry
* Persist: (persist).  Persistant variables for Emacs.
@end direntry
@copying
Copyright @copyright{} 2019 Phillip Lord
@quotation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with the Front-Cover, or Back-Cover Texts.  A copy of
the license is included in the section entitled ``GNU Free Documentation
License'' in the Emacs manual.
This document is part of a collection distributed under the GNU Free
Documentation License.  If you want to distribute this document
separately from the collection, you can do so by adding a copy of the
license to the document, as described in section 6 of the license.
All Emacs Lisp code contained in this document may be used, distributed,
and modified without restriction.
@end quotation
@end copying
@titlepage
@title Persist -- Persistant Variables for Emacs
@author by Phillip Lord
@page
@insertcopying
@end titlepage
@contents
@node Top
@top Persist -- Persistant Variables for Emacs
Perist is a library for making variables persistant; that it, their
state can be changed from the default and the new value will remain even
after Emacs has been closed and restarted.
@menu
* Persist::                     Simple Usage
* The details::        All functions for interacting with Persist
* Comparison::                  How this relates to other, similar techniques
* Implementation::              How variables are saved
@end menu
@node Persist
@section Persist
This section describes simple usage of persist.
@defmac persist-defvar (var initvalue docstring) body@dots{}
This macro is equivalent in form to @code{defvar}, except any changes to
the value of @code{var} will persist between sessions.  This macro does
not support the lower arity versions of @code{defvar}. Both an
@code{initvalue} and @code{docstring} needs to be provided.
@end defmac
@example
@group
(persist-defvar my-persistant-variable 10
   "A variable of no purpose.
   
This variable is persistant between sessions")
@end group
@end example
@node The details
@section The details
@defmac persist-defvar (var initvalue docstring) body@dots{}
This macro is equivalent to @code{defvar} and can be used to make a
variable persistant.
@end defmac
@defun persist-symbol (symbol &optional initvalue)
This function takes @code{symbol} for an existing, non-persistant variable
and makes it persistant. If @code{initvalue} is not given, then the
current value is used. For package developers, @code{persist-defvar}
would generally be prefered; this function might be useful for making
third-party variables persistant.
@end defun
@example
@group
(defvar my-persistant-variable 10
    "A variable of no purpose")
(persist-symbol 'my-persistant-variable 10)
@end group
@end example
@defun persist-save (symbol)
This function saves @code{symbol} immediately rather than waiting till
the normal time
@end defun
@defun persist-default (symbol)
Return the default value for @code{symbol}. The default value is
actually set for each session and does not persist from session to
session, although if the value is set by either @code{persist-defvar} or
@code{persist-symbol} saved it in a file, it will be set to the same
value across sessions.
@end defun
@defun persist-reset (symbol)
Change the value of @code{symbol} to the last saved value if it exists.
@end defun
@defun persist-location (symbol directory)
Values are usually persisted to a standard location; it is possible to
change this for individual symbol using this function. Be aware that
this does not call @code{persist-load}, so this will not restore a
previously saved value.
@end defun
@node Comparison
@section Comparison
There are several other packages which also persist aspects of Emacs
across sessions, however, these fulfil a different purpose.
Custom persists values of variables across sessions. However, it does
this for user options, and is associated with a user interface for
editing the value.
desktop.el is also user-centric and is aimed at persisting the session
in terms of buffers, modes and minor modes. It can be used to persist
individual variables, but this will also save the session which the user
may or may not want.
savehist.el can save individual variables but, as with desktop.el, is a
a global setting and has other implications such as saving mini-buffer
history.
@node Implementation
@section Implementation
persist is implemented by saving values for each symbol into an
different. This makes it relatively easy to update or delete the stored
value for a variable by hand if necessary. It should scale to 10 or 100
variables, but may get a bit slow after this.
@bye

;;; persist.el --- Persist Variables between Emacs Sessions -*- lexical-binding: t -*-
;; Copyright (C) 2019 Free Software Foundation, Inc.
;; Author: Phillip Lord <phillip.lord@russet.org.uk>
;; Maintainer: Phillip Lord <phillip.lord@russet.org.uk>
;; Package-Type: multi
;; Version: 0.5
;; The contents of this file are subject to the GPL License, Version 3.0.
;; This file is not part of Emacs
;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; This package provides variables which persist across sessions.
;; The main entry point is `persist-defvar' which behaves like
;; `defvar' but which persists the variables between session.  Variables
;; are automatically saved when Emacs exits.
;; Other useful functions are `persist-save' which saves the variable
;; immediately, `persist-load' which loads the saved value,
;; `persist-reset' which resets to the default value.
;; Values are stored in a directory in `user-emacs-directory', using
;; one file per value.  This makes it easy to delete or remove unused
;; variables.
;;; Code:
(defvar persist--directory-location
  (locate-user-emacs-file "persist")
  "The location of persist directory.")
(defvar persist--symbols nil
  "List of symbols to persist.")
(defvar persist-load-hook nil
  "Special hook run on loading a variable.
Hook functions are called with two values: the symbol and the
value it will be set to.  If any function returns nil, the
variable is not set to the value.")
(defun persist--file-location (symbol)
  "Return the file name at which SYMBOL does or will persist."
  (expand-file-name
   (symbol-name symbol)
   (or (get symbol 'persist-location)
       persist--directory-location)))
(defun persist--defvar-1 (symbol location)
  "Set symbol up for persistance."
  (when location
    (persist-location symbol location))
  (persist-symbol symbol (symbol-value symbol))
  (persist-load symbol))
(defmacro persist-defvar (symbol initvalue docstring &optional location)
  "Define SYMBOL as a persistant variable and return SYMBOL.
This form is nearly equivalent to `defvar', except that the
variable persists between Emacs sessions.
It does not support the optional parameters.  Both INITVALUE and
DOCSTRING need to be given."
  ;; We cannot distinguish between calls with initvalue of nil and a
  ;; single parameter call. Unfortunately, these two calls have
  ;; different semantics -- the single arity shuts up the byte
  ;; compiler, but does not define the symbol. So, don't support a
  ;; single arity persist-defvar.
  ;; Don't support 2-arity calls either because we are lazy and
  ;; because if you want to persist it, you want to doc it.
  (declare (debug (symbolp form stringp &optional form)) (doc-string 3))
  ;; Define inside progn so the byte compiler sees defvar
  `(progn
     (defvar ,symbol ,initvalue ,docstring)
     ;; Access initvalue through its symbol because the defvar form
     ;; has to stay at first level within a progn
     (persist--defvar-1 ',symbol ,location)
     ',symbol))
(defun persist-location (symbol directory)
  "Set the directory for persisting the value of symbol.
This does not force the loading of value from this directory, so
to persist a variable, you will normally need to call
`persist-load' to load a previously saved location."
  (put symbol 'persist-location (expand-file-name directory)))
(defun persist-symbol (symbol &optional initvalue)
  "Make SYMBOL a persistant variable.
If non-nil, INITVALUE is the value to which SYMBOL will be set if
`persist-reset' is called.  Otherwise, the INITVALUE will be the
current `symbol-value' of SYMBOL.
INITVALUE is set for the session and will itself not persist
across sessions.
This does force the loading of value from this directory, so to
persist a variable, you will normally need to call `persist-load'
to load a previously saved location."
  (let ((initvalue (or initvalue (symbol-value symbol))))
    (add-to-list 'persist--symbols symbol)
    (put symbol 'persist t)
    (put symbol 'persist-default initvalue)))
(defun persist--persistant-p (symbol)
  "Return non-nil if SYMBOL is a persistant variable."
  (get symbol 'persist))
(defun persist-save (symbol)
  "Save SYMBOL now.
Normally, it should not be necessary to call this explicitly, as
variables persist automatically when Emacs exits."
  (unless (persist--persistant-p symbol)
    (error (format
            "Symbol %s is not persistant" symbol)))
  (let ((symbol-file-loc (persist--file-location symbol)))
    (if (equal (symbol-value symbol)
               (persist-default symbol))
        (when (file-exists-p symbol-file-loc)
          (delete-file symbol-file-loc))
      (let ((dir-loc
             (file-name-directory symbol-file-loc)))
        (unless (file-exists-p dir-loc)
          (mkdir dir-loc))
        (with-temp-buffer
          (let (print-level
                print-length
                print-quoted
                (print-escape-control-characters t)
                (print-escape-nonascii t)
                (print-circle t))
            (print (symbol-value symbol) (current-buffer)))
          (write-region (point-min) (point-max)
                        symbol-file-loc
                        nil 'quiet))))))
(defun persist-default (symbol)
  "Return the default value for SYMBOL."
  (get symbol 'persist-default))
(defun persist-reset (symbol)
  "Reset the value of SYMBOL to the default."
  (set symbol (persist-default symbol)))
(defun persist-load (symbol)
  "Load the saved value of SYMBOL."
  (when (file-exists-p (persist--file-location symbol))
    (with-temp-buffer
      (insert-file-contents (persist--file-location symbol))
      (let ((val (read (current-buffer))))
        (when (run-hook-with-args-until-failure 'persist-load-hook
                                                symbol val)
          (set symbol val))))))
(defun persist-unpersist (symbol)
  "Stop the value in SYMBOL from persisting.
This does not remove any saved value of SYMBOL."
  (put symbol 'persist nil)
  (setq persist--symbols
        (remove symbol persist--symbols)))
(defun persist--save-all ()
  "Save all persistant symbols."
  (mapc 'persist-save persist--symbols))
;; Save on kill-emacs-hook anyway
(add-hook 'kill-emacs-hook
          'persist--save-all)
(provide 'persist)
;;; persist.el ends here

;; Generated package description from persist.el  -*- no-byte-compile: t -*-
(define-package "persist" "0.5" "Persist Variables between Emacs Sessions" 'nil :commit "25d675307c03f720e592c3dc9a5a0ae8db0836eb" :url "https://elpa.gnu.org/packages/persist.html" :authors '(("Phillip Lord" . "phillip.lord@russet.org.uk")) :maintainer '("Phillip Lord" . "phillip.lord@russet.org.uk"))

;;; persist-autoloads.el --- automatically extracted autoloads  -*- lexical-binding: t -*-
;;
;;; Code:
(add-to-list 'load-path (directory-file-name
                         (or (file-name-directory #$) (car load-path))))

;;;### (autoloads nil "persist" "persist.el" (0 0 0 0))
;;; Generated autoloads from persist.el
(register-definition-prefixes "persist" '("persist-"))
;;;***

;;;### (autoloads nil nil ("persist-pkg.el") (0 0 0 0))
;;;***

;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; persist-autoloads.el ends here

Makefile
Cask
.gitignore

This is mastodon.info, produced by makeinfo version 6.7 from
mastodon.texi.
INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Mastodon: (mastodon). Client for Mastodon on ActivityPub networks.
END-INFO-DIR-ENTRY

File: mastodon.info,  Node: Top,  Next: README,  Up: (dir)
* Menu:
* README::
— The Detailed Node Listing —
README
* Installation::
* Usage::
* Dependencies::
* Network compatibility::
* Contributing::
* Supporting ‘mastodon.el’: Supporting mastodonel.
* Contributors::
Installation
* MELPA::
* Emoji::
* Discover::
Usage
* Logging in to your instance::
* Timelines::
* Composing toots::
* Other commands and account settings::
* Customization::
* Alternative timeline layout::
* Live-updating timelines mastodon-async-mode::
* Translating toots::
* bookmarks and ‘mastodon.el’: bookmarks and mastodonel.
Contributing
* Bug reports::
* Fixes and features::
* Coding style::

File: mastodon.info,  Node: README,  Prev: Top,  Up: Top
1 README
********
‘mastodon.el’ is an Emacs client for the AcitivityPub social networks
that implement the Mastodon API.  For info see joinmastodon.org
(https://joinmastodon.org/).
* Menu:
* Installation::
* Usage::
* Dependencies::
* Network compatibility::
* Contributing::
* Supporting ‘mastodon.el’: Supporting mastodonel.
* Contributors::

File: mastodon.info,  Node: Installation,  Next: Usage,  Up: README
1.1 Installation
================
Clone this repository and add the lisp directory to your load path.
Then, require it and go.
     (add-to-list 'load-path "/path/to/mastodon.el/lisp")
     (require 'mastodon)
   Or, with ‘use-package’:
     (use-package mastodon
       :ensure t)
   The minimum Emacs version is now 27.1.  But if you are running an
older version it shouldn’t be very hard to get it working.
* Menu:
* MELPA::
* Emoji::
* Discover::

File: mastodon.info,  Node: MELPA,  Next: Emoji,  Up: Installation
1.1.1 MELPA
-----------
Add ‘MELPA’ to your archives:
     (require 'package)
     (add-to-list 'package-archives
                  '("melpa" . "http://melpa.org/packages/") t)
   Update and install:
   ‘M-x package-refresh-contents RET’
   ‘M-x package-install RET mastodon RET’

File: mastodon.info,  Node: Emoji,  Next: Discover,  Prev: MELPA,  Up: Installation
1.1.2 Emoji
-----------
‘mastodon-mode’ will enable Emojify
(https://github.com/iqbalansari/emacs-emojify) if it is loaded in your
Emacs environment, so there’s no need to write your own hook anymore.
‘emojify-mode’ is not required.

File: mastodon.info,  Node: Discover,  Prev: Emoji,  Up: Installation
1.1.3 Discover
--------------
‘mastodon-mode’ can provide a context menu for its keybindings if
Discover (https://github.com/mickeynp/discover.el) is installed.  It is
not required.
   if you have Discover, add the following to your Emacs init
configuration:
     (require 'mastodon-discover)
     (with-eval-after-load 'mastodon (mastodon-discover))
   Or, with ‘use-package’:
     (use-package mastodon
       :ensure t
       :config
       (mastodon-discover))

File: mastodon.info,  Node: Usage,  Next: Dependencies,  Prev: Installation,  Up: README
1.2 Usage
=========
* Menu:
* Logging in to your instance::
* Timelines::
* Composing toots::
* Other commands and account settings::
* Customization::
* Alternative timeline layout::
* Live-updating timelines mastodon-async-mode::
* Translating toots::
* bookmarks and ‘mastodon.el’: bookmarks and mastodonel.

File: mastodon.info,  Node: Logging in to your instance,  Next: Timelines,  Up: Usage
1.2.1 Logging in to your instance
---------------------------------
You need to set 2 variables in your init file to get started:
  1. ‘mastodon-instance-url’
  2. ‘mastodon-active-user’
   (see their doc strings for details).  For example If you want to post
toots as "example_user@social.instance.org", then put this in your init
file:
     (setq mastodon-instance-url "https://social.instance.org"
           mastodon-active-user "example_user")
   Then *restart* Emacs and run ‘M-x mastodon’.  Make sure you are
connected to internet before you do this.  If you have multiple mastodon
accounts you can activate one at a time by changing those two variables
and restarting Emacs.
   If you were using mastodon.el before 2FA was implemented and the
above steps do not work, delete the old file specified by
‘mastodon-client--token-file’ and restart Emacs and follow the steps
again.

File: mastodon.info,  Node: Timelines,  Next: Composing toots,  Prev: Logging in to your instance,  Up: Usage
1.2.2 Timelines
---------------
‘M-x mastodon’
   Opens a ‘*mastodon-home*’ buffer in the major mode and displays
toots.  If your credentials are not yet saved, you will be prompted for
email and password.  The app registration process will take place if
your ‘mastodon-token-file’ does not contain ‘:client_id’ and
‘:client_secret’.
  1. Keybindings
     Key                      Action
     -----------------------------------------------------------------------------------------------------------
                              *Help*
     ‘?’                      Show discover menu of all bindings, if ‘discover’ is available
                              *Timeline actions*
     ‘n’                      Go to next item (toot, notification, user)
     ‘p’                      Go to previous item (toot, notification, user)
     ‘M-n=/=<tab>’            Go to the next interesting thing that has an action
     ‘M-p=/=<S-tab>’          Go to the previous interesting thing that has an action
     ‘F’                      Open federated timeline (1 prefix arg: hide-replies, 2 prefix args: media only)
     ‘H’                      Open home timeline (1 prefix arg: hide-replies)
     ‘L’                      Open local timeline (1 prefix arg: hide-replies, 2 prefix args: media only)
     ‘N’                      Open notifications timeline
     ‘@’                      Open mentions-only notifications timeline
     ‘u’                      Update current timeline
     ‘T’                      Open thread for toot at point
     ‘#’                      Prompt for tag and open its timeline
     ‘A’                      Open author profile of toot at point
     ‘P’                      Open profile of user attached to toot at point
     ‘O’                      View own profile
     ‘U’                      update your profile bio note
     ‘;’                      view instance description for toot at point
     ‘:’                      view followed tags and load a tag timeline
     ‘C-:’                    view timeline of all followed tags
     ‘,’                      view favouriters of toot at point
     ‘.’                      view boosters of toot at point
     ‘/’                      switch between mastodon buffers
     ‘Z’                      report user/toot at point to instances moderators
                              *Other views*
     ‘s’                      search (posts, users, tags) (NB: only posts you have interacted with)
     ‘I’, ‘c’, ‘d’            view, create, and delete filters
     ‘R’, ‘a’, ‘j’            view/accept/reject follow requests
     ‘G’                      view follow suggestions
     ‘V’                      view your favourited toots
     ‘K’                      view bookmarked toots
     ‘X’                      view/edit/create/delete lists
     ‘S’                      view your scheduled toots
                              *Toot actions*
     ‘t’                      Compose a new toot
     ‘c’                      Toggle content warning content
     ‘b’                      Boost toot under ‘point’
     ‘f’                      Favourite toot under ‘point’
     ‘k’                      toggle bookmark of toot at point
     ‘r’                      Reply to toot under ‘point’
     ‘v’                      Vote on poll at point
     ‘C’                      copy url of toot at point
     ‘C-RET’                  play video/gif at point (requires ‘mpv’)
     ‘e’                      edit your toot at point
     ‘E’                      view edits of toot at point
     ‘i’                      (un)pin your toot at point
     ‘d’                      delete your toot at point, and reload current timeline
     ‘D’                      delete and redraft toot at point, preserving reply/CW/visibility
     (‘S-C-’) ‘W’, ‘M’, ‘B’   (un)follow, (un)mute, (un)block author of toot at point
                              *Profile view*
     ‘C-c C-c’                cycle between statuses, statuses without boosts, followers, and following
                              ‘mastodon-profile--account-account-to-list’ (see lists view)
                              *Notifications view*
     ‘a’, ‘j’                 accept/reject follow request
     ‘C-k’                    clear notification at point
                              see ‘mastodon-notifications--get-*’ functions for filtered views
                              *Quitting*
     ‘q’                      Quit mastodon buffer, leave window open
     ‘Q’                      Quit mastodon buffer and kill window
     ‘C-M-q’                  Quit and kill all mastodon buffers
  2. Toot byline legend
     Marker             Meaning
     --------------------------------------------
     ‘(🔁)’ (or          I boosted this toot
     ‘(B)’)
     ‘(⭐)’ (or          I favourited this toot
     ‘(F)’)
     ‘(🔖)’ (or          I bookmarked this toot
     (‘K’))

File: mastodon.info,  Node: Composing toots,  Next: Other commands and account settings,  Prev: Timelines,  Up: Usage
1.2.3 Composing toots
---------------------
‘M-x mastodon-toot’ (or ‘t’ from a mastodon.el buffer) opens a new
buffer/window in ‘text-mode’ and ‘mastodon-toot’ minor mode.  Enter the
contents of your toot here.  ‘C-c C-c’ sends the toot.  ‘C-c C-k’
cancels.  Both actions kill the buffer and window.  Further keybindings
are displayed in the buffer, and in the following subsection.
   Replies preserve visibility status/content warnings, and include
boosters by default.
   Server’s max toot length, and attachment previews, are shown.
   You can download and use your instance’s custom emoji
(‘mastodon-toot--download-custom-emoji’,
‘mastodon-toot--enable-custom-emoji’).
   The compose buffer uses ‘text-mode’ so any configuration you have for
that mode will be enabled.  If any of your existing config conflicts
with ‘mastodon-toot’, you can disable it in the
‘mastodon-toot-mode-hook’.  For example, the default value of that hook
is as follows:
     (add-hook 'mastodon-toot-mode-hook
               (lambda ()
                   (auto-fill-mode -1)))
  1. Keybindings
     Key         Action
     -------------------------------------------------
     ‘C-c C-c’   Send toot
     ‘C-c C-k’   Cancel toot
     ‘C-c C-w’   Add content warning
     ‘C-c C-v’   Change toot visibility
     ‘C-c C-n’   Add sensitive media/nsfw flag
     ‘C-c C-a’   Upload attachment(s)
     ‘C-c !’     Remove all attachments
     ‘C-c C-e’   Add emoji (if ‘emojify’ installed)
     ‘C-c C-p’   Create a poll
     ‘C-c C-l’   Set toot language
  2. autocompletion of mentions and tags
     Autocompletion of mentions and tags is provided by
     ‘completion-at-point-functions’ (capf) backends.
     ‘mastodon-toot--enable-completion’ is enabled by default.  If you
     want to enable ‘company-mode’ in the toot compose buffer, set
     ‘mastodon-toot--use-company-for-completion’ to ‘t’.  (‘mastodon.el’
     used to run its own native company backends, but these have been
     removed in favour of capfs.)
     If you don’t run ‘company’ and want immediate, keyless completion,
     you’ll need to have another completion engine running that handles
     capfs.  A common combination is ‘consult’ and ‘corfu’.
  3. Draft toots
        • Compose buffer text is saved as you type, kept in
          ‘mastodon-toot-current-toot-text’.
        • ‘mastodon-toot--save-draft’: save the current toot as a draft.
        • ‘mastodon-toot--open-draft-toot’: Open a compose buffer and
          insert one of your draft toots.
        • ‘mastodon-toot--delete-draft-toot’: Delete a draft toot.
        • ‘mastodon-toot--delete-all-drafts’: Delete all your drafts.

File: mastodon.info,  Node: Other commands and account settings,  Next: Customization,  Prev: Composing toots,  Up: Usage
1.2.4 Other commands and account settings:
------------------------------------------
In addition to ‘mastodon’, the following three functions are autoloaded
and should work without first loading ‘mastodon.el’:
   • ‘mastodon-toot’: Compose new toot
   • ‘mastodon-notifications-get’: View all notifications
   • ‘mastodon-url-lookup’: Attempt to load a URL in ‘mastodon.el’.  URL
     may be at point or provided in the minibuffer.
   • ‘mastodon-tl--view-instance-description’: View information about
     the instance that the author of the toot at point is on.
   • ‘mastodon-tl--view-own-instance’: View information about your own
     instance.
   • ‘mastodon-search--trending-tags’: View a list of trending hashtags
     on your instance.
   • ‘mastodon-search--trending-statuses’: View a list of trending
     statuses on your instance.
   • ‘mastodon-tl--add-toot-account-at-point-to-list’: Add the account
     of the toot at point to a list.
   • ‘mastodon-tl--dm-user’: Send a direct message to one of the users
     at point.
   • ‘mastodon-profile--add-private-note-to-account’: Add a private note
     to another user’s account.
   • ‘mastodon-profile--view-account-private-note’: View a private note
     on a user’s account.
   • ‘mastodon-profile--show-familiar-followers’: Show a list of
     “familiar followers” for a given account.  Familiar followers are
     accounts that you follow, and that follow the account.
   • ‘mastodon-tl--follow-tag’: Follow a tag (works like following a
     user)
   • ‘mastodon-tl--unfollow-tag’: Unfollow a tag
   • ‘mastodon-tl--list-followed-tags’: View a list of tags you’re
     following.
   • ‘mastodon-tl--followed-tags-timeline’: View a timeline of all your
     followed tags.
   • ‘mastodon-tl--some-followed-tags-timleine’: View a timeline of
     multiple tags, from your followed tags or any other.
   • ‘mastodon-switch-to-buffer’: switch between mastodon buffers.
   • ‘mastodon-profile--update-display-name’: Update the display name
     for your account.
   • ‘mastodon-profile--update-user-profile-note’: Update your bio note.
   • ‘mastodon-profile--update-meta-fields’: Update your metadata
     fields.
   • ‘mastodon-profile--set-default-toot-visibility’: Set the default
     visibility for your toots.
   • ‘mastodon-profile--account-locked-toggle’: Toggle the locked status
     of your account.  Locked accounts have to manually approve follow
     requests.
   • ‘mastodon-profile--account-discoverable-toggle’: Toggle the
     discoverable status of your account.  Non-discoverable accounts are
     not listed in the profile directory.
   • ‘mastodon-profile--account-bot-toggle’: Toggle whether your account
     is flagged as a bot.
   • ‘mastodon-profile--account-sensitive-toggle’: Toggle whether your
     posts are marked as sensitive (nsfw) by default.

File: mastodon.info,  Node: Customization,  Next: Alternative timeline layout,  Prev: Other commands and account settings,  Up: Usage
1.2.5 Customization
-------------------
See ‘M-x customize-group RET mastodon’ to view all customize options.
   • Timeline options:
        • Use proportional fonts
        • Default number of posts displayed
        • Timestamp format
        • Relative timestamps
        • Display user avatars
        • Avatar image height
        • Enable image caching
        • Hide replies in timelines
        • Show toot stats in byline
   • Compose options:
        • Completion style for mentions and tags
        • Enable custom emoji
        • Display toot being replied to
        • Set default reply visibility

File: mastodon.info,  Node: Alternative timeline layout,  Next: Live-updating timelines mastodon-async-mode,  Prev: Customization,  Up: Usage
1.2.6 Alternative timeline layout
---------------------------------
The incomparable Nicholas Rougier has written an alternative timeline
layout for ‘mastodon.el’.
   The repo is at mastodon-alt
(https://github.com/rougier/mastodon-alt).

File: mastodon.info,  Node: Live-updating timelines mastodon-async-mode,  Next: Translating toots,  Prev: Alternative timeline layout,  Up: Usage
1.2.7 Live-updating timelines: ‘mastodon-async-mode’
----------------------------------------------------
(code taken from mastodon-future
(https://github.com/alexjgriffith/mastodon-future.el).)
   Works for federated, local, and home timelines and for notifications.
It’s a little touchy, one thing to avoid is trying to load a timeline
more than once at a time.  It can go off the rails a bit, but it’s still
pretty cool.  The current maintainer of ‘mastodon.el’ is unable to debug
or improve this feature.
   To enable, it, add ‘(require 'mastodon-async)’ to your ‘init.el’.
Then you can view a timeline with one of the commands that begin with
‘mastodon-async--stream-’.

File: mastodon.info,  Node: Translating toots,  Next: bookmarks and mastodonel,  Prev: Live-updating timelines mastodon-async-mode,  Up: Usage
1.2.8 Translating toots
-----------------------
You can translate toots with ‘mastodon-toot--translate-toot-text’ (‘a’
in a timeline).  At the moment this requires lingva.el
(https://codeberg.org/martianh/lingva.el), a little interface I wrote to
lingva.ml (https://lingva.ml), to be installed to work.
   You could easily modify the simple function to use your Emacs
translator of choice (‘libretrans.el’ , ‘google-translate’, ‘babel’,
‘go-translate’, etc.), you just need to fetch the toot’s content with
‘(mastodon-tl--content toot)’ and pass it to your translator function as
its text argument.  Here’s what ‘mastodon-toot--translate-toot-text’
looks like:
     (defun mastodon-toot--translate-toot-text ()
       "Translate text of toot at point.
       Uses `lingva.el'."
         (interactive)
         (let* ((toot (mastodon-tl--property 'toot-json)))
           (if toot
               (lingva-translate nil (mastodon-tl--content toot))
             (message "No toot to translate?"))))

File: mastodon.info,  Node: bookmarks and mastodonel,  Prev: Translating toots,  Up: Usage
1.2.9 bookmarks and ‘mastodon.el’
---------------------------------
‘mastodon.el’ doesn’t currently implement its own bookmark record and
handler, which means that emacs bookmarks will not work as is.  Until we
implement them, you can get bookmarks going immediately by using
bookmark+.el
(https://github.com/emacsmirror/emacswiki.org/blob/master/bookmark%2b.el).

File: mastodon.info,  Node: Dependencies,  Next: Network compatibility,  Prev: Usage,  Up: README
1.3 Dependencies
================
Hard dependencies (should all install with ‘mastodon.el’):
   • ‘request’ (for uploading attachments), emacs-request
     (https://github.com/tkf/emacs-request)
   • ‘persist’ for storing some settings across sessions
   • ‘ts’ for poll relative expiry times
   Optional dependencies:
   • ‘emojify’ for inserting and viewing emojis
   • ‘mpv’ and ‘mpv.el’ for viewing videos and gifs
   • ‘lingva.el’ for translating toots

File: mastodon.info,  Node: Network compatibility,  Next: Contributing,  Prev: Dependencies,  Up: README
1.4 Network compatibility
=========================
‘mastodon.el’ should work with ActivityPub servers that implement the
Mastodon API.
   Apart from Mastodon itself, it is currently known to work with
Pleroma and Gotosocial.  If you attempt to use ‘mastodon.el’ with
another server that implements the Mastodon API and run into problems,
feel free to open an issue.

File: mastodon.info,  Node: Contributing,  Next: Supporting mastodonel,  Prev: Network compatibility,  Up: README
1.5 Contributing
================
PRs, issues, feature requests, and general feedback are very welcome!
* Menu:
* Bug reports::
* Fixes and features::
* Coding style::

File: mastodon.info,  Node: Bug reports,  Next: Fixes and features,  Up: Contributing
1.5.1 Bug reports
-----------------
  1. ‘mastodon.el’ has bugs, as well as lots of room for improvement.
  2. I receive very little feedback, so if I don’t run into the bug it
     often doesn’t get fixed.
  3. If you run into something that seems broken, first try running
     ‘mastodon.el’ in emacs with no init file (i.e.  ‘emacs -q’
     (instructions and code for doing this are here
     (https://codeberg.org/martianh/mastodon.el/issues/300)) to see if
     it also happens independently of your own config (it probably
     does).
  4. Enable debug on error (‘toggle-debug-on-error’), make the bug
     happen again, and copy the backtrace that appears.
  5. Open an issue here and explain what is going on.  Provide your
     emacs version and what kind of server your account is on.

File: mastodon.info,  Node: Fixes and features,  Next: Coding style,  Prev: Bug reports,  Up: Contributing
1.5.2 Fixes and features
------------------------
  1. Create an issue (https://codeberg.org/martianh/mastodon.el/issues)
     detailing what you’d like to do.
  2. Fork the repository and create a branch off of ‘develop’.
  3. Run the tests and ensure that your code doesn’t break any of them.
  4. Create a pull request referencing the issue created in step 1.

File: mastodon.info,  Node: Coding style,  Prev: Fixes and features,  Up: Contributing
1.5.3 Coding style
------------------
   • This library uses an unconvential double dash (‘--’) between file
     namespaces and function names, which contradicts normal Elisp
     style.  This needs to be respected until the whole library is
     changed.
   • Use ‘aggressive-indent-mode’ or similar to keep your code indented.
   • Single spaces end sentences in docstrings.
   • There’s no need for a blank line after the first docstring line
     (one is added automatically when documentation is displayed).

File: mastodon.info,  Node: Supporting mastodonel,  Next: Contributors,  Prev: Contributing,  Up: README
1.6 Supporting ‘mastodon.el’
============================
If you’d like to support continued development of ‘mastodon.el’, I
accept donations via paypal: paypal.me/martianh
(https://paypal.me/martianh).  If you would prefer a different payment
method, write to me at that address and I can provide IBAN or other
details.
   I don’t have a tech worker’s income, so even a small tip would help
out.

File: mastodon.info,  Node: Contributors,  Prev: Supporting mastodonel,  Up: README
1.7 Contributors
================
‘mastodon.el’ is the work of a number of people.
   Some significant contributors are:
   • <https://github.com/jdenen> [original author]
   • <http://atomized.org>
   • <https://alexjgriffith.itch.io>
   • <https://github.com/hdurer>
   • <https://codeberg.org/Red_Starfish>

Tag Table:
Node: Top210
Node: README911
Node: Installation1327
Node: MELPA1863
Node: Emoji2231
Node: Discover2563
Node: Usage3115
Node: Logging in to your instance3525
Node: Timelines4522
Ref: Keybindings4997
Ref: Toot byline legend9570
Node: Composing toots9879
Ref: Keybindings (1)11118
Ref: autocompletion of mentions and tags11636
Ref: Draft toots12349
Node: Other commands and account settings12820
Node: Customization15978
Node: Alternative timeline layout16764
Node: Live-updating timelines mastodon-async-mode17154
Node: Translating toots18006
Node: bookmarks and mastodonel19188
Node: Dependencies19658
Node: Network compatibility20264
Node: Contributing20750
Node: Bug reports21039
Node: Fixes and features21945
Node: Coding style22428
Node: Supporting mastodonel23052
Node: Contributors23574

End Tag Table

Local Variables:
coding: utf-8
End:

;;; mastodon.el --- Client for fediverse services using the Mastodon API  -*- lexical-binding: t -*-
;; Copyright (C) 2017-2019 Johnson Denen
;; Copyright (C) 2020-2022 Marty Hiatt
;; Copyright (C) 2021 Abhiseck Paira <abhiseckpaira@disroot.org>
;; Author: Johnson Denen <johnson.denen@gmail.com>
;;         Marty Hiatt <martianhiatus@riseup.net>
;; Maintainer: Marty Hiatt <martianhiatus@riseup.net>
;; Version: 1.0.0
;; Package-Requires: ((emacs "27.1") (request "0.3.0") (persist "0.4") (ts "0.3"))
;; Homepage: https://codeberg.org/martianh/mastodon.el
;; This file is not part of GNU Emacs.
;; This file is part of mastodon.el.
;; mastodon.el is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; mastodon.el is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with mastodon.el.  If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; mastodon.el is a client for fediverse services that implement the Mastodon
;; API. See <https://github.com/mastodon/mastodon>.
;; See the readme file at https://codeberg.org/martianh/mastodon.el for set up
;; and usage details.
;;; Code:
(require 'cl-lib) ; for `cl-some' call in mastodon
(eval-when-compile (require 'subr-x))
(require 'mastodon-http)
(require 'mastodon-toot)
(require 'mastodon-search)
(require 'url)
(require 'thingatpt)
(require 'shr)
(declare-function discover-add-context-menu "discover")
(declare-function emojify-mode "emojify")
(declare-function request "request")
(autoload 'mastodon-auth--get-account-name "mastodon-auth")
(autoload 'mastodon-auth--user-acct "mastodon-auth")
(autoload 'mastodon-discover "mastodon-discover")
(autoload 'mastodon-notifications--follow-request-accept "mastodon-notifications")
(autoload 'mastodon-notifications--follow-request-reject "mastodon-notifications")
(autoload 'mastodon-notifications--get-mentions "mastodon-notifications")
(autoload 'mastodon-notifications--timeline "mastodon-notifications")
(autoload 'mastodon-profile--fetch-server-account-settings "mastodon-profile")
(autoload 'mastodon-profile--get-toot-author "mastodon-profile")
(autoload 'mastodon-profile--make-author-buffer "mastodon-profile")
(autoload 'mastodon-profile--my-profile "mastodon-profile")
(autoload 'mastodon-profile--show-user "mastodon-profile")
(autoload 'mastodon-profile--update-user-profile-note "mastodon-profile")
(autoload 'mastodon-profile--view-bookmarks "mastodon-profile")
(autoload 'mastodon-profile--view-favourites "mastodon-profile")
(autoload 'mastodon-tl--block-user "mastodon-tl")
(autoload 'mastodon-tl--follow-user "mastodon-tl")
(autoload 'mastodon-tl--followed-tags-timeline "mastodon-tl")
(autoload 'mastodon-tl--get-buffer-type "mastodon-tl")
(autoload 'mastodon-tl--get-federated-timeline "mastodon-tl")
(autoload 'mastodon-tl--get-home-timeline "mastodon-tl")
(autoload 'mastodon-tl--get-local-timeline "mastodon-tl")
(autoload 'mastodon-tl--get-tag-timeline "mastodon-tl")
(autoload 'mastodon-tl--goto-next-toot "mastodon-tl")
(autoload 'mastodon-tl--goto-prev-toot "mastodon-tl")
(autoload 'mastodon-tl--init-sync "mastodon-tl")
(autoload 'mastodon-tl--list-followed-tags "mastodon-tl")
(autoload 'mastodon-tl--mute-user "mastodon-tl")
(autoload 'mastodon-tl--next-tab-item "mastodon-tl")
(autoload 'mastodon-tl--poll-vote "mastodon-http")
(autoload 'mastodon-tl--previous-tab-item "mastodon-tl")
(autoload 'mastodon-tl--thread "mastodon-tl")
(autoload 'mastodon-tl--toggle-spoiler-text-in-toot "mastodon-tl")
(autoload 'mastodon-tl--unblock-user "mastodon-tl")
(autoload 'mastodon-tl--unfollow-user "mastodon-tl")
(autoload 'mastodon-tl--unmute-user "mastodon-tl")
(autoload 'mastodon-tl--report-to-mods "mastodon-tl")
(autoload 'mastodon-tl--update "mastodon-tl")
(autoload 'mastodon-toot--edit-toot-at-point "mastodon-toot")
(when (require 'lingva nil :no-error)
  (autoload 'mastodon-toot--translate-toot-text "mastodon-toot"))
(autoload 'mastodon-toot--view-toot-history "mastodon-tl")
(autoload 'mastodon-views--view-follow-suggestions "mastodon-views")
(autoload 'mastodon-views--view-filters "mastodon-views")
(autoload 'mastodon-views--view-follow-requests "mastodon-views")
(autoload 'mastodon-views--view-instance-description "mastodon-views")
(autoload 'mastodon-views--view-lists "mastodon-views")
(autoload 'mastodon-views--view-scheduled-toots "mastodon-views")
(autoload 'special-mode "simple")
(defvar mastodon-notifications--map)
(defgroup mastodon nil
  "Interface with Mastodon."
  :prefix "mastodon-"
  :group 'external)
(defcustom mastodon-instance-url "https://mastodon.social"
  "Base URL for the Mastodon instance you want to be active.
For example, if your mastodon username is
\"example_user@social.instance.org\", and you want this account
to be active, the value of this variable should be
\"https://social.instance.org\".
Also for completeness, the value of `mastodon-active-user' should
be \"example_user\".
After setting these variables you should restart Emacs for these
changes to take effect."
  :type 'string)
(defcustom mastodon-active-user nil
  "Username of the active user.
For example, if your mastodon username is
\"example_user@social.instance.org\", and you want this account
to be active, the value of this variable should be
\"example_user\".
Also for completeness, the value of `mastodon-instance-url'
should be \"https://social.instance.org\".
After setting these variables you should restart Emacs for these
changes to take effect."
  :type 'string)
(defcustom mastodon-toot-timestamp-format "%F %T"
  "Format to use for timestamps.
For valid formatting options see `format-time-string`.
The default value \"%F %T\" prints ISO8601-style YYYY-mm-dd HH:MM:SS.
Use. e.g. \"%c\" for your locale's date and time format."
  :type 'string)
(defvar mastodon-mode-map
  (let ((map (make-sparse-keymap)))
    ;; navigation inside a timeline
    (define-key map (kbd "n") #'mastodon-tl--goto-next-toot)
    (define-key map (kbd "p") #'mastodon-tl--goto-prev-toot)
    (define-key map (kbd "M-n") #'mastodon-tl--next-tab-item)
    (define-key map (kbd "M-p") #'mastodon-tl--previous-tab-item)
    (define-key map [?\t] #'mastodon-tl--next-tab-item)
    (define-key map [backtab] #'mastodon-tl--previous-tab-item)
    (define-key map [?\S-\t] #'mastodon-tl--previous-tab-item)
    (define-key map [?\M-\t] #'mastodon-tl--previous-tab-item)
    (define-key map (kbd "l") #'recenter-top-bottom)
    ;; navigation between timelines
    (define-key map (kbd "#") #'mastodon-tl--get-tag-timeline)
    (define-key map (kbd ":") #'mastodon-tl--list-followed-tags)
    (define-key map (kbd "C-:") #'mastodon-tl--followed-tags-timeline)
    (define-key map (kbd "A") #'mastodon-profile--get-toot-author)
    (define-key map (kbd "F") #'mastodon-tl--get-federated-timeline)
    (define-key map (kbd "H") #'mastodon-tl--get-home-timeline)
    (define-key map (kbd "L") #'mastodon-tl--get-local-timeline)
    (define-key map (kbd "N") #'mastodon-notifications-get)
    (define-key map (kbd "@") #'mastodon-notifications--get-mentions)
    (define-key map (kbd "P") #'mastodon-profile--show-user)
    (define-key map (kbd "s") #'mastodon-search--search-query)
    (define-key map (kbd "/") #'mastodon-switch-to-buffer)
    ;; quitting mastodon
    (define-key map (kbd "q") #'kill-current-buffer)
    (define-key map (kbd "Q") #'kill-buffer-and-window)
    (define-key map (kbd "M-C-q") #'mastodon-kill-all-buffers)
    ;; toot actions
    (define-key map (kbd "c") #'mastodon-tl--toggle-spoiler-text-in-toot)
    (define-key map (kbd "b") #'mastodon-toot--toggle-boost)
    (define-key map (kbd "f") #'mastodon-toot--toggle-favourite)
    (define-key map (kbd "k") #'mastodon-toot--toggle-bookmark)
    (define-key map (kbd "r") #'mastodon-toot--reply)
    (define-key map (kbd "C") #'mastodon-toot--copy-toot-url)
    (define-key map (kbd "v") #'mastodon-tl--poll-vote)
    (define-key map (kbd "E") #'mastodon-toot--view-toot-edits)
    (define-key map (kbd "T") #'mastodon-tl--thread)
    (when (require 'lingva nil :no-error)
      (define-key map (kbd "a") #'mastodon-toot--translate-toot-text))
    (define-key map (kbd ",") #'mastodon-toot--list-toot-favouriters)
    (define-key map (kbd ".") #'mastodon-toot--list-toot-boosters)
    (define-key map (kbd ";") #'mastodon-views--view-instance-description)
    ;; override special mode binding
    (define-key map (kbd "g") #'undefined)
    (define-key map (kbd "g") #'mastodon-tl--update)
    ;; this is now duplicated by 'g', cd remove/use for else:
    (define-key map (kbd "u") #'mastodon-tl--update)
    ;; own toot actions:
    (define-key map (kbd "t") #'mastodon-toot)
    (define-key map (kbd "d") #'mastodon-toot--delete-toot)
    (define-key map (kbd "D") #'mastodon-toot--delete-and-redraft-toot)
    (define-key map (kbd "i") #'mastodon-toot--pin-toot-toggle)
    (define-key map (kbd "e") #'mastodon-toot--edit-toot-at-point)
    ;; user actions
    (define-key map (kbd "W") #'mastodon-tl--follow-user)
    (define-key map (kbd "C-S-W") #'mastodon-tl--unfollow-user)
    (define-key map (kbd "B") #'mastodon-tl--block-user)
    (define-key map (kbd "C-S-B") #'mastodon-tl--unblock-user)
    (define-key map (kbd "M") #'mastodon-tl--mute-user)
    (define-key map (kbd "C-S-M") #'mastodon-tl--unmute-user)
    (define-key map (kbd "Z") #'mastodon-tl--report-to-mods)
    ;; own profile
    (define-key map (kbd "O") #'mastodon-profile--my-profile)
    (define-key map (kbd "U") #'mastodon-profile--update-user-profile-note)
    (define-key map (kbd "V") #'mastodon-profile--view-favourites)
    (define-key map (kbd "K") #'mastodon-profile--view-bookmarks)
    ;; minor views
    (define-key map (kbd "R") #'mastodon-views--view-follow-requests)
    (define-key map (kbd "S") #'mastodon-views--view-scheduled-toots)
    (define-key map (kbd "I") #'mastodon-views--view-filters)
    (define-key map (kbd "G") #'mastodon-views--view-follow-suggestions)
    (define-key map (kbd "X") #'mastodon-views--view-lists)
    map)
  "Keymap for `mastodon-mode'.")
(defcustom mastodon-mode-hook nil
  "Hook run when entering Mastodon mode."
  :type 'hook
  :options '(provide-discover-context-menu)
  :group 'mastodon)
(defface mastodon-handle-face
  '((t :inherit default))
  "Face used for user handles in bylines.")
(defface mastodon-display-name-face
  '((t :inherit warning))
  "Face used for user display names.")
(defface mastodon-boosted-face
  '((t :inherit success :weight bold))
  "Face to indicate that a toot is boosted.")
(defface mastodon-boost-fave-face
  '((t :inherit success))
  "Face to indicate that you have boosted or favourited a toot.")
(defface mastodon-cw-face
  '((t :inherit success))
  "Face used for content warning.")
(defface mastodon-toot-docs-face
  `((t :inherit font-lock-comment-face))
  "Face used for documentation in toot compose buffer.
If `mastodon-tl--enable-proportional-fonts' is changed,
mastodon.el needs to be re-loaded for this to be correctly set.")
(defface mastodon-toot-docs-reply-text-face
  `((t :inherit font-lock-comment-face
       :family ,(face-attribute 'variable-pitch :family)))
  "Face used for reply text in toot compose buffer.
See `mastodon-toot-display-orig-in-reply-buffer'.")
;;;###autoload
(defun mastodon ()
  "Connect Mastodon client to `mastodon-instance-url' instance."
  (interactive)
  (let* ((tls (list "home"
                    "local"
                    "federated"
                    (concat (mastodon-auth--user-acct) "-statuses") ; own profile
                    "favourites"
                    "search"))
         (buffer (or (cl-some (lambda (el)
                                (get-buffer (concat "*mastodon-" el "*")))
                              tls) ; return first buff that exists
                     (cl-some (lambda (x)
                                (when
                                    (string-prefix-p "*mastodon-" (buffer-name x))
                                  (get-buffer x)))
                              (buffer-list))))) ; catch any other masto buffer
    (if buffer
        (switch-to-buffer buffer)
      (mastodon-tl--get-home-timeline)
      (message "Loading Mastodon account %s on %s..."
               (mastodon-auth--user-acct)
               mastodon-instance-url))))
;;;###autoload
(defun mastodon-toot (&optional user reply-to-id reply-json)
  "Update instance with new toot. Content is captured in a new buffer.
If USER is non-nil, insert after @ symbol to begin new toot.
If REPLY-TO-ID is non-nil, attach new toot to a conversation.
If REPLY-JSON is the json of the toot being replied to."
  (interactive)
  (mastodon-toot--compose-buffer user reply-to-id reply-json))
;;;###autoload
(defun mastodon-notifications-get (&optional type buffer-name force)
  "Display NOTIFICATIONS in buffer.
Optionally only print notifications of type TYPE, a string.
BUFFER-NAME is added to \"*mastodon-\" to create the buffer name.
FORCE means do not try to update an existing buffer, but fetch
from the server and load anew."
  (interactive)
  (let ((buffer (if buffer-name
                    (concat "*mastodon-" buffer-name "*")
                  "*mastodon-notifications*")))
    (if (and (not force)
             (get-buffer buffer))
        (progn (switch-to-buffer buffer)
               (mastodon-tl--update))
      (message "Loading your notifications...")
      (mastodon-tl--init-sync
       (or buffer-name "notifications")
       "notifications"
       'mastodon-notifications--timeline
       type)
      (with-current-buffer buffer
        (use-local-map mastodon-notifications--map)))))
;; URL lookup: should be available even if `mastodon.el' not loaded:
;;;###autoload
(defun mastodon-url-lookup (&optional query-url)
  "If a URL resembles a mastodon link, try to load in `mastodon.el'.
Does a WebFinger lookup.
URL can be arg QUERY-URL, or URL at point, or provided by the user.
If a status or account is found, load it in `mastodon.el', if
not, just browse the URL in the normal fashion."
  (interactive)
  (let* ((query (or query-url
                    (thing-at-point-url-at-point)
                    (mastodon-tl--property 'shr-url :no-move)
                    (read-string "Lookup URL: "))))
    (if (not (mastodon--masto-url-p query))
        ;; this doesn't work as shr-browse-url doesn't take a url arg
        ;; and with no args it can't use our read-string query, but only
        ;; looks for a url at point
        ;; (if (equal major-mode 'mastodon-mode)
        ;; (shr-browse-url query) ;; keep our shr keymap
        (browse-url query)
      (message "Performing lookup...")
      (let* ((url (format "%s/api/v2/search" mastodon-instance-url))
             (params `(("q" . ,query)
                       ("resolve" . "t"))) ; webfinger
             (response (mastodon-http--get-json url params :silent)))
        (cond ((not (seq-empty-p
                     (alist-get 'statuses response)))
               (let* ((statuses (assoc 'statuses response))
                      (status (seq-first (cdr statuses)))
                      (status-id (alist-get 'id status)))
                 (mastodon-tl--thread status-id)))
              ((not (seq-empty-p
                     (alist-get 'accounts response)))
               (let* ((accounts (assoc 'accounts response))
                      (account (seq-first (cdr accounts))))
                 (mastodon-profile--make-author-buffer account)))
              (t
               (browse-url query)))))))
(defun mastodon--masto-url-p (query)
  "Check if QUERY resembles a fediverse URL."
  ;; calqued off https://github.com/tuskyapp/Tusky/blob/c8fc2418b8f5458a817bba221d025b822225e130/app/src/main/java/com/keylesspalace/tusky/BottomSheetActivity.kt
  ;; thx to Conny Duck!
  (let* ((uri-parsed (url-generic-parse-url query))
         (query (url-filename uri-parsed)))
    (save-match-data
      (or (string-match "^/@[^/]+$" query)
          (string-match "^/@[^/]+/[[:digit:]]+$" query)
          (string-match "^/user[s]?/[[:alnum:]]+$" query)
          (string-match "^/notice/[[:alnum:]]+$" query)
          (string-match "^/objects/[-a-f0-9]+$" query)
          (string-match "^/notes/[a-z0-9]+$" query)
          (string-match "^/display/[-a-f0-9]+$" query)
          (string-match "^/profile/[[:alpha:]]+$" query)
          (string-match "^/p/[[:alpha:]]+/[[:digit:]]+$" query)
          (string-match "^/[[:alpha:]]+$" query)
          (string-match "^/u/[[:alpha:]]+$" query)))))
(defun mastodon-live-buffers ()
  "Return a list of open mastodon buffers.
Calls `mastodon-tl--get-buffer-type', which see."
  (cl-loop for x in (buffer-list)
           when (with-current-buffer x (mastodon-tl--get-buffer-type))
           collect (get-buffer x)))
(defun mastodon-kill-all-buffers ()
  "Kill any and all open mastodon buffers, hopefully."
  (interactive)
  (let ((mastodon-buffers (mastodon-live-buffers)))
    (cl-loop for x in mastodon-buffers
             do (kill-buffer x))))
(defun mastodon-switch-to-buffer ()
  "Switch to a live mastodon buffer."
  (interactive)
  (let* ((bufs (mastodon-live-buffers))
         (buf-names (mapcar #'buffer-name bufs))
         (choice (completing-read "Switch to mastodon buffer: "
                                  buf-names)))
    (switch-to-buffer choice)))
;;;###autoload
(add-hook 'mastodon-mode-hook (lambda ()
                                (when (require 'emojify nil :noerror)
                                  (emojify-mode t)
                                  (when mastodon-toot--enable-custom-instance-emoji
                                    (mastodon-toot--enable-custom-emoji)))))
;;;###autoload
(add-hook 'mastodon-mode-hook #'mastodon-profile--fetch-server-account-settings)
(define-derived-mode mastodon-mode special-mode "Mastodon"
  "Major mode for Mastodon, the federated microblogging network."
  :group 'mastodon
  (read-only-mode 1))
(provide 'mastodon)
;;; mastodon.el ends here

;;; mastodon-views.el --- Minor views functions for mastodon.el  -*- lexical-binding: t -*-
;; Copyright (C) 2020-2022 Marty Hiatt
;; Author: Marty Hiatt <martianhiatus@riseup.net>
;; Maintainer: Marty Hiatt <martianhiatus@riseup.net>
;; Version: 1.0.0
;; Homepage: https://codeberg.org/martianh/mastodon.el
;; This file is not part of GNU Emacs.
;; This file is part of mastodon.el.
;; mastodon.el is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; mastodon.el is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with mastodon.el.  If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; mastodon-views.el provides minor views functions.
;; These are currently lists, follow suggestions, filters, scheduled toots,
;; follow requests, and instance descriptions.
;; It doesn't include favourites, bookmarks, preferences, trending tags, followed tags, toot edits,
;;; Code:
(require 'cl-lib)
(require 'mastodon-http)
(eval-when-compile
  (require 'mastodon-tl))
(defvar mastodon-mode-map)
(defvar mastodon-tl--horiz-bar)
(defvar mastodon-tl--timeline-posts-count)
(autoload 'mastodon-mode "mastodon")
(autoload 'mastodon-tl--init "mastodon-tl")
(autoload 'mastodon-tl--init-sync "mastodon-tl")
(autoload 'mastodon-tl--field "mastodon-tl")
(autoload 'mastodon-tl--property "mastodon-tl")
(autoload 'mastodon-tl--set-face "mastodon-tl")
(autoload 'mastodon-tl--buffer-type-eq "mastodon-tl")
(autoload 'mastodon-tl--profile-buffer-p "mastodon-tl")
(autoload 'mastodon-tl--goto-next-item "mastodon-tl")
(autoload 'mastodon-tl--goto-prev-item "mastodon-tl")
(autoload 'mastodon-tl--goto-first-item "mastodon-tl")
(autoload 'mastodon-tl--do-if-toot "mastodon-tl")
(autoload 'mastodon-tl--set-buffer-spec "mastodon-tl")
(autoload 'mastodon-tl--render-text "mastodon-tl")
(autoload 'mastodon-notifications--follow-request-accept "mastodon-notifications")
(autoload 'mastodon-notifications--follow-request-reject "mastodon-notifications")
(autoload 'mastodon-auth--get-account-id "mastodon-auth")
(autoload 'mastodon-toot--iso-to-human "mastodon-toot")
(autoload 'mastodon-toot--schedule-toot "mastodon-toot")
(autoload 'mastodon-toot--compose-buffer "mastodon-toot")
(autoload 'mastodon-toot--set-toot-properties "mastodon-toot")
(autoload 'mastodon-search--propertize-user "mastodon-search")
(autoload 'mastodon-search--insert-users-propertized "mastodon-search")
(autoload 'mastodon-tl--map-alist "mastodon-tl")
(autoload 'mastodon-tl--map-alist-vals-to-alist "mastodon-tl")

;;; KEYMAPS
;; we copy `mastodon-mode-map', as then all timeline functions are
;; available. this is helpful because if a minor view is the only buffer left
;; open, calling `mastodon' will switch to it, but then we will be unable to
;; switch to timlines without closing the minor view.
;; copying the mode map however means we need to avoid/unbind/override any
;; functions that might cause interfere with the minor view.
;; this is not redundant, as while the buffer -init function calls
;; `mastodon-mode', it gets overridden in some but not all cases.
(defvar mastodon-views-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map mastodon-mode-map)
    (define-key map (kbd "n") #'mastodon-tl--goto-next-item)
    (define-key map (kbd "p") #'mastodon-tl--goto-prev-item)
    map)
  "Base keymap for minor mastodon views.")
(defvar mastodon-views--view-filters-keymap
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map mastodon-views-map)
    (define-key map (kbd "d") #'mastodon-views--delete-filter)
    (define-key map (kbd "c") #'mastodon-views--create-filter)
    (define-key map (kbd "TAB") #'mastodon-tl--goto-next-item)
    (define-key map (kbd "g") #'mastodon-views--view-filters)
    map)
  "Keymap for viewing filters.")
(defvar mastodon-views--follow-suggestions-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map mastodon-views-map)
    (define-key map (kbd "g") #'mastodon-views--view-follow-suggestions)
    map)
  "Keymap for viewing follow suggestions.")
(defvar mastodon-views--view-lists-keymap
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map mastodon-views-map)
    (define-key map (kbd "D") #'mastodon-views--delete-list)
    (define-key map (kbd "C") #'mastodon-views--create-list)
    (define-key map (kbd "A") #'mastodon-views--add-account-to-list)
    (define-key map (kbd "R") #'mastodon-views--remove-account-from-list)
    (define-key map (kbd "E") #'mastodon-views--edit-list)
    (define-key map (kbd "g") #'mastodon-views--view-lists)
    map)
  "Keymap for viewing lists.")
(defvar mastodon-views--list-name-keymap
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "RET") #'mastodon-views--view-timeline-list-at-point)
    (define-key map (kbd "d") #'mastodon-views--delete-list-at-point)
    (define-key map (kbd "a") #'mastodon-views--add-account-to-list-at-point)
    (define-key map (kbd "r") #'mastodon-views--remove-account-from-list-at-point)
    (define-key map (kbd "e") #'mastodon-views--edit-list-at-point)
    map)
  "Keymap for when point is on list name.")
(defvar mastodon-views--scheduled-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map mastodon-views-map)
    (define-key map (kbd "r") #'mastodon-views--reschedule-toot)
    (define-key map (kbd "c") #'mastodon-views--cancel-scheduled-toot)
    (define-key map (kbd "e") #'mastodon-views--edit-scheduled-as-new)
    (define-key map (kbd "RET") #'mastodon-views--edit-scheduled-as-new)
    map)
  "Keymap for when point is on a scheduled toot.")
(defvar mastodon-views--view-follow-requests-keymap
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map mastodon-views-map)
    ;; make reject binding match the binding in notifs view
    ;; 'r' is then reserved for replying, even tho it is not avail
    ;; in foll-reqs view
    (define-key map (kbd "j") #'mastodon-notifications--follow-request-reject)
    (define-key map (kbd "a") #'mastodon-notifications--follow-request-accept)
    (define-key map (kbd "g") #'mastodon-views--view-follow-requests)
    map)
  "Keymap for viewing follow requests.")

;;; GENERAL FUNCTION
(defun mastodon-views--minor-view (view-name bindings-string insert-fun data)
  "Load a minor view named VIEW-NAME.
BINDINGS-STRING is a string explaining the view's local bindings.
INSERT-FUN is the function to call to insert the view's elements.
DATA is the argument to insert-fun, usually JSON returned in a
request.
This function is used as the update-function to
`mastodon-tl--init-sync', which initializes a buffer for us and
provides the JSON data."
  (erase-buffer)
  (insert (mastodon-tl--set-face
           (concat "\n " mastodon-tl--horiz-bar "\n "
                   (upcase view-name)
                   "\n "
                   mastodon-tl--horiz-bar "\n\n")
           'success)
          (if bindings-string
              (mastodon-tl--set-face
               (concat "[" bindings-string "]"
                       "\n\n")
               'font-lock-comment-face)
            ""))
  (if (seq-empty-p data)
      (insert (propertize
               (format "Looks like you have no %s for now." view-name)
               'face font-lock-comment-face
               'byline t
               'toot-id "0")) ; so point can move here when no filters
    (funcall insert-fun data)
    (goto-char (point-min)))
  ;; (when json
  ;; FIXME: this seems to trigger a new request, but ideally would run.
  ;; (mastodon-tl--goto-next-toot))))
  )

;;; LISTS
(defun mastodon-views--view-lists ()
  "Show the user's lists in a new buffer."
  (interactive)
  (mastodon-tl--init-sync "lists"
                          "lists"
                          'mastodon-views--insert-lists)
  (with-current-buffer "*mastodon-lists*"
    (use-local-map mastodon-views--view-lists-keymap)))
(defun mastodon-views--insert-lists (json)
  "Insert the user's lists from JSON."
  (mastodon-views--minor-view
   "your lists"
   "C - create a list\n D - delete a list\
     \n A/R - add/remove account from a list\
     \n E - edit a list\n n/p - go to next/prev item"
   #'mastodon-views--print-list-set
   json))
(defun mastodon-views--print-list-set (lists)
  "Print each account plus a separator for each list in LISTS."
  (let ((lists-names
         (mastodon-tl--map-alist 'title lists)))
    (mapc (lambda (x)
            (mastodon-views--print-list-accounts x)
            (insert (propertize (concat " " mastodon-tl--horiz-bar "\n\n")
                                'face 'success)))
          lists-names)))
(defun mastodon-views--print-list-accounts (list-name)
  "Insert the accounts in list named LIST-NAME."
  (let* ((id (mastodon-views--get-list-id list-name))
         (accounts (mastodon-views--accounts-in-list id)))
    (insert
     (propertize list-name
                 'byline t ; so we nav here
                 'toot-id "0" ; so we nav here
                 'help-echo "RET: view list timeline, d: delete this list, \
a: add account to this list, r: remove account from this list"
                 'list t
                 'face 'link
                 'keymap mastodon-views--list-name-keymap
                 'list-name list-name
                 'list-id id)
     (propertize
      "\n\n"
      'list t
      'keymap mastodon-views--list-name-keymap
      'list-name list-name
      'list-id id)
     (propertize
      (mapconcat #'mastodon-search--propertize-user accounts
                 " ")
      ;; (mastodon-search--insert-users-propertized accounts)
      'list t
      'keymap mastodon-views--list-name-keymap
      'list-name list-name
      'list-id id))))
(defun mastodon-views--get-users-lists ()
  "Get the list of the user's lists from the server."
  (let ((url (mastodon-http--api "lists")))
    (mastodon-http--get-json url)))
(defun mastodon-views--get-lists-names ()
  "Return a list of the user's lists' names."
  (let ((lists (mastodon-views--get-users-lists)))
    (mastodon-tl--map-alist 'title lists)))
(defun mastodon-views--get-list-by-name (name)
  "Return the list data for list with NAME."
  (let* ((lists (mastodon-views--get-users-lists)))
    (cl-loop for list in lists
             if (string= (alist-get 'title list) name)
             return list)))
(defun mastodon-views--get-list-id (name)
  "Return id for list with NAME."
  (let ((list (mastodon-views--get-list-by-name name)))
    (alist-get 'id list)))
(defun mastodon-views--get-list-name (id)
  "Return name of list with ID."
  (let* ((url (mastodon-http--api (format "lists/%s" id)))
         (response (mastodon-http--get-json url)))
    (alist-get 'title response)))
(defun mastodon-views--edit-list-at-point ()
  "Edit list at point."
  (interactive)
  (let ((id (mastodon-tl--property 'list-id :no-move)))
    (mastodon-views--edit-list id)))
(defun mastodon-views--edit-list (&optional id)
  "Prompt for a list and edit the name and replies policy.
If ID is provided, use that list."
  (interactive)
  (let* ((list-names (unless id (mastodon-views--get-lists-names)))
         (name-old (if id
                       (mastodon-tl--property 'list-name :no-move)
                     (completing-read "Edit list: "
                                      list-names)))
         (id (or id (mastodon-views--get-list-id name-old)))
         (name-choice (read-string "List name: " name-old))
         (replies-policy (completing-read "Replies policy: " ; give this a proper name
                                          '("followed" "list" "none")
                                          nil t nil nil "list"))
         (url (mastodon-http--api (format "lists/%s" id)))
         (response (mastodon-http--put url
                                       `(("title" . ,name-choice)
                                         ("replies_policy" . ,replies-policy)))))
    (mastodon-http--triage response
                           (lambda ()
                             (with-current-buffer response
                               (let* ((json (mastodon-http--process-json))
                                      (name-new (alist-get 'title json)))
                                 (message "list %s edited to %s!" name-old name-new)))
                             (when (mastodon-tl--buffer-type-eq 'lists)
                               (mastodon-views--view-lists))))))
(defun mastodon-views--view-timeline-list-at-point ()
  "View timeline of list at point."
  (interactive)
  (let ((list-id (mastodon-tl--property 'list-id :no-move)))
    (mastodon-views--view-list-timeline list-id)))
(defun mastodon-views--view-list-timeline (&optional id)
  "Prompt for a list and view its timeline.
If ID is provided, use that list."
  (interactive)
  (let* ((list-names (unless id (mastodon-views--get-lists-names)))
         (list-name (unless id (completing-read "View list: " list-names)))
         (id (or id (mastodon-views--get-list-id list-name)))
         (endpoint (format "timelines/list/%s" id))
         (name (mastodon-views--get-list-name id))
         (buffer-name (format "list-%s" name)))
    (mastodon-tl--init buffer-name endpoint
                       'mastodon-tl--timeline
                       nil
                       `(("limit" . ,mastodon-tl--timeline-posts-count)))))
(defun mastodon-views--create-list ()
  "Create a new list.
Prompt for name and replies policy."
  (interactive)
  (let* ((title (read-string "New list name: "))
         (replies-policy (completing-read "Replies policy: " ; give this a proper name
                                          '("followed" "list" "none")
                                          nil t nil nil "list")) ; default
         (response (mastodon-http--post (mastodon-http--api "lists")
                                        `(("title" . ,title)
                                          ("replies_policy" . ,replies-policy))
                                        nil)))
    (mastodon-views--list-action-triage response
                                        (message "list %s created!" title))))
(defun mastodon-views--delete-list-at-point ()
  "Delete list at point."
  (interactive)
  (let ((id (mastodon-tl--property 'list-id :no-move)))
    (mastodon-views--delete-list id)))
(defun mastodon-views--delete-list (&optional id)
  "Prompt for a list and delete it.
If ID is provided, delete that list."
  (interactive)
  (let* ((list-names (unless id (mastodon-views--get-lists-names)))
         (name (if id
                   (mastodon-views--get-list-name id)
                 (completing-read "Delete list: "
                                  list-names)))
         (id (or id (mastodon-views--get-list-id name)))
         (url (mastodon-http--api (format "lists/%s" id))))
    (when (y-or-n-p (format "Delete list %s?" name))
      (let ((response (mastodon-http--delete url)))
        (mastodon-views--list-action-triage response
                                            (message "list %s deleted!" name))))))
(defun mastodon-views--get-users-followings ()
  "Return the list of followers of the logged in account."
  (let* ((id (mastodon-auth--get-account-id))
         (url (mastodon-http--api (format "accounts/%s/following" id))))
    (mastodon-http--get-json url '(("limit" . "80"))))) ; max 80 accounts
(defun mastodon-views--add-account-to-list-at-point ()
  "Prompt for account and add to list at point."
  (interactive)
  (let ((id (mastodon-tl--property 'list-id :no-move)))
    (mastodon-views--add-account-to-list id)))
(defun mastodon-views--add-account-to-list (&optional id account-id handle)
  "Prompt for a list and for an account, add account to list.
If ID is provided, use that list.
If ACCOUNT-ID and HANDLE are provided use them rather than prompting."
  (interactive)
  (let* ((list-prompt (if handle
                          (format "Add %s to list: " handle)
                        "Add account to list: "))
         (list-name (if id
                        (mastodon-tl--property 'list-name :no-move)
                      (completing-read list-prompt
                                       (mastodon-views--get-lists-names) nil t)))
         (list-id (or id (mastodon-views--get-list-id list-name)))
         (followings (mastodon-views--get-users-followings))
         (handles (mastodon-tl--map-alist-vals-to-alist 'acct 'id followings))
         (account (or handle (completing-read "Account to add: "
                                              handles nil t)))
         (account-id (or account-id (alist-get account handles nil nil 'equal)))
         (url (mastodon-http--api (format "lists/%s/accounts" list-id)))
         (response (mastodon-http--post url
                                        `(("account_ids[]" . ,account-id)))))
    (mastodon-views--list-action-triage
     response
     (message "%s added to list %s!" account list-name))))
(defun mastodon-views--add-toot-account-at-point-to-list ()
  "Prompt for a list, and add the account of the toot at point to it."
  (interactive)
  (let* ((toot (mastodon-tl--property 'toot-json))
         (account (mastodon-tl--field 'account toot))
         (account-id (mastodon-tl--field 'id account))
         (handle (mastodon-tl--field 'acct account)))
    (mastodon-views--add-account-to-list nil account-id handle)))
(defun mastodon-views--remove-account-from-list-at-point ()
  "Prompt for account and remove from list at point."
  (interactive)
  (let ((id (mastodon-tl--property 'list-id :no-move)))
    (mastodon-views--remove-account-from-list id)))
(defun mastodon-views--remove-account-from-list (&optional id)
  "Prompt for a list, select an account and remove from list.
If ID is provided, use that list."
  (interactive)
  (let* ((list-name (if id
                        (mastodon-tl--property 'list-name :no-move)
                      (completing-read "Remove account from list: "
                                       (mastodon-views--get-lists-names) nil t)))
         (list-id (or id (mastodon-views--get-list-id list-name)))
         (accounts (mastodon-views--accounts-in-list list-id))
         (handles (mastodon-tl--map-alist-vals-to-alist 'acct 'id accounts))
         (account (completing-read "Account to remove: "
                                   handles nil t))
         (account-id (alist-get account handles nil nil 'equal))
         (url (mastodon-http--api (format "lists/%s/accounts" list-id)))
         (args (mastodon-http--build-array-params-alist "account_ids[]" `(,account-id)))
         (response (mastodon-http--delete url args)))
    (mastodon-views--list-action-triage
     response
     (message "%s removed from list %s!" account list-name))))
(defun mastodon-views--list-action-triage (response message)
  "Call `mastodon-http--triage' on RESPONSE and display MESSAGE."
  (mastodon-http--triage response
                         (lambda ()
                           (when (mastodon-tl--buffer-type-eq 'lists)
                             (mastodon-views--view-lists))
                           message)))
(defun mastodon-views--accounts-in-list (list-id)
  "Return the JSON of the accounts in list with LIST-ID."
  (let* ((url (mastodon-http--api (format "lists/%s/accounts" list-id))))
    (mastodon-http--get-json url)))

;;; FOLLOW REQUESTS
(defun mastodon-views--insert-follow-requests (json)
  "Insert the user's current follow requests.
JSON is the data returned by the server."
  (mastodon-views--minor-view
   "follow requests"
   "a/j - accept/reject request at point\n n/p - go to next/prev request"
   #'mastodon-views--insert-users-propertized-note
   json))
(defun mastodon-views--view-follow-requests ()
  "Open a new buffer displaying the user's follow requests."
  (interactive)
  (mastodon-tl--init-sync "follow-requests"
                          "follow_requests"
                          'mastodon-views--insert-follow-requests)
  (mastodon-tl--goto-first-item)
  (with-current-buffer "*mastodon-follow-requests*"
    (use-local-map mastodon-views--view-follow-requests-keymap)))

;;; SCHEDULED TOOTS
(defun mastodon-views--view-scheduled-toots ()
  "Show the user's scheduled toots in a new buffer."
  (interactive)
  (mastodon-tl--init-sync "scheduled-toots"
                          "scheduled_statuses"
                          'mastodon-views--insert-scheduled-toots)
  (with-current-buffer "*mastodon-scheduled-toots*"
    (use-local-map mastodon-views--scheduled-map)))
(defun mastodon-views--insert-scheduled-toots (json)
  "Insert the user's scheduled toots, from JSON."
  (mastodon-views--minor-view
   "your scheduled toots"
   "n/p - prev/next\n r - reschedule\n e/RET - edit toot\n c - cancel"
   #'mastodon-views--insert-scheduled-toots-list
   json))
(defun mastodon-views--insert-scheduled-toots-list (scheduleds)
  "Insert scheduled toots in SCHEDULEDS."
  (mapc #'mastodon-views--insert-scheduled-toot scheduleds))
(defun mastodon-views--insert-scheduled-toot (toot)
  "Insert scheduled TOOT into the buffer."
  (let* ((id (alist-get 'id toot))
         (scheduled (alist-get 'scheduled_at toot))
         (params (alist-get 'params toot))
         (text (alist-get 'text params)))
    (insert
     (propertize (concat text
                         " | "
                         (mastodon-toot--iso-to-human scheduled))
                 'byline t ; so we nav here
                 'toot-id "0" ; so we nav here
                 'face 'font-lock-comment-face
                 'keymap mastodon-views--scheduled-map
                 'scheduled-json toot
                 'id id)
     "\n")))
(defun mastodon-views--get-scheduled-toots (&optional id)
  "Get the user's currently scheduled toots.
If ID, just return that toot."
  (let* ((endpoint (if id
                       (format "scheduled_statuses/%s" id)
                     "scheduled_statuses"))
         (url (mastodon-http--api endpoint)))
    (mastodon-http--get-json url)))
(defun mastodon-views--reschedule-toot ()
  "Reschedule the scheduled toot at point."
  (interactive)
  (let ((id (mastodon-tl--property 'id :no-move)))
    (if (null id)
        (message "no scheduled toot at point?")
      (mastodon-toot--schedule-toot :reschedule))))
(defun mastodon-views--copy-scheduled-toot-text ()
  "Copy the text of the scheduled toot at point."
  (interactive)
  (let* ((toot (mastodon-tl--property 'toot :no-move))
         (params (alist-get 'params toot))
         (text (alist-get 'text params)))
    (kill-new text)))
(defun mastodon-views--cancel-scheduled-toot (&optional id no-confirm)
  "Cancel the scheduled toot at point.
ID is that of the scheduled toot to cancel.
NO-CONFIRM means there is no ask or message, there is only do."
  (interactive)
  (let ((id (or id (mastodon-tl--property 'id :no-move))))
    (if (null id)
        (message "no scheduled toot at point?")
      (when (or no-confirm
                (y-or-n-p "Cancel scheduled toot?"))
        (let* ((url (mastodon-http--api (format "scheduled_statuses/%s" id)))
               (response (mastodon-http--delete url)))
          (mastodon-http--triage response
                                 (lambda ()
                                   (mastodon-views--view-scheduled-toots)
                                   (unless no-confirm
                                     (message "Toot cancelled!")))))))))
(defun mastodon-views--edit-scheduled-as-new ()
  "Edit scheduled status as new toot."
  (interactive)
  (let ((id (mastodon-tl--property 'id :no-move)))
    (if (null id)
        (message "no scheduled toot at point?")
      (let* ((toot (mastodon-tl--property 'scheduled-json :no-move))
             (scheduled (alist-get 'scheduled_at toot))
             (params (alist-get 'params toot))
             (text (alist-get 'text params))
             (visibility (alist-get 'visibility params))
             (cw (alist-get 'spoiler_text params))
             (lang (alist-get 'language params))
             ;; (poll (alist-get 'poll params))
             (reply-id (alist-get 'in_reply_to_id params)))
        ;; (media (alist-get 'media_attachments toot)))
        (mastodon-toot--compose-buffer)
        (goto-char (point-max))
        (insert text)
        ;; adopt properties from scheduled toot:
        (mastodon-toot--set-toot-properties reply-id visibility cw
                                            lang scheduled id)))))

;;; FILTERS
(defun mastodon-views--view-filters ()
  "View the user's filters in a new buffer."
  (interactive)
  (mastodon-tl--init-sync "filters"
                          "filters"
                          'mastodon-views--insert-filters)
  (with-current-buffer "*mastodon-filters*"
    (use-local-map mastodon-views--view-filters-keymap)))
(defun mastodon-views--insert-filters (json)
  "Insert the user's current filters.
JSON is what is returned by by the server."
  (mastodon-views--minor-view
   "current filters"
   "c - create filter\n d - delete filter at point\n n/p - go to next/prev filter"
   #'mastodon-views--insert-filter-string-set
   json))
(defun mastodon-views--insert-filter-string-set (json)
  "Insert a filter string plus a blank line.
JSON is the filters data."
  (mapc (lambda (x)
          (mastodon-views--insert-filter-string x)
          (insert "\n\n"))
        json))
(defun mastodon-views--insert-filter-string (filter)
  "Insert a single FILTER."
  (let* ((phrase (alist-get 'phrase filter))
         (contexts (alist-get 'context filter))
         (id (alist-get 'id filter))
         (filter-string (concat "- \"" phrase "\" filtered in: "
                                (mapconcat #'identity contexts ", "))))
    (insert
     (propertize filter-string
                 'toot-id id ;for goto-next-filter compat
                 'phrase phrase
                 ;;'help-echo "n/p to go to next/prev filter, c to create new filter, d to delete filter at point."
                 ;;'keymap mastodon-views--view-filters-keymap
                 'byline t)))) ;for goto-next-filter compat
(defun mastodon-views--create-filter ()
  "Create a filter for a word.
Prompt for a context, must be a list containting at least one of \"home\",
\"notifications\", \"public\", \"thread\"."
  (interactive)
  (let* ((url (mastodon-http--api "filters"))
         (word (read-string
                (format "Word(s) to filter (%s): " (or (current-word) ""))
                nil nil (or (current-word) "")))
         (contexts
          (if (string-empty-p word)
              (error "You must select at least one word for a filter")
            (completing-read-multiple
             "Contexts to filter [TAB for options]: "
             '("home" "notifications" "public" "thread")
             nil ; no predicate
             t))) ; require-match, as context is mandatory
         (contexts-processed
          (if (equal nil contexts)
              (error "You must select at least one context for a filter")
            (mapcar (lambda (x)
                      (cons "context[]" x))
                    contexts)))
         (response (mastodon-http--post url (push
                                             `("phrase" . ,word)
                                             contexts-processed))))
    (mastodon-http--triage response
                           (lambda ()
                             (message "Filter created for %s!" word)
                             ;; reload if we are in filters view:
                             (when (mastodon-tl--buffer-type-eq 'filters)
                               (mastodon-views--view-filters))))))
(defun mastodon-views--delete-filter ()
  "Delete filter at point."
  (interactive)
  (let* ((filter-id (mastodon-tl--property 'toot-id :no-move))
         (phrase (mastodon-tl--property 'phrase :no-move))
         (url (mastodon-http--api
               (format "filters/%s" filter-id))))
    (if (null phrase)
        (error "No filter at point?")
      (when (y-or-n-p (format "Delete filter %s? " phrase)))
      (let ((response (mastodon-http--delete url)))
        (mastodon-http--triage response (lambda ()
                                          (mastodon-views--view-filters)
                                          (message "Filter for \"%s\" deleted!" phrase)))))))

;;; FOLLOW SUGGESTIONS
(defun mastodon-views--view-follow-suggestions ()
  "Display a buffer of suggested accounts to follow."
  (interactive)
  (mastodon-tl--init-sync "follow-suggestions"
                          "suggestions"
                          'mastodon-views--insert-follow-suggestions)
  (with-current-buffer "*mastodon-follow-suggestions*"
    (use-local-map mastodon-views--follow-suggestions-map)))
(defun mastodon-views--insert-follow-suggestions (json)
  "Insert follow suggestions into buffer.
JSON is the data returned by the server."
  (mastodon-views--minor-view
   "suggested accounts"
   nil
   #'mastodon-views--insert-users-propertized-note
   json))
(defun mastodon-views--insert-users-propertized-note (json)
  "Insert users list into the buffer, including profile note.
JSON is the users list data."
  (mastodon-search--insert-users-propertized json :note))

;;; INSTANCES
(defun mastodon-views--view-own-instance (&optional brief)
  "View details of your own instance.
BRIEF means show fewer details."
  (interactive)
  (mastodon-views--view-instance-description :user brief))
(defun mastodon-views--view-own-instance-brief ()
  "View brief details of your own instance."
  (interactive)
  (mastodon-views--view-instance-description :user :brief))
(defun mastodon-views--view-instance-description-brief ()
  "View brief details of the instance the current post's author is on."
  (interactive)
  (mastodon-views--view-instance-description nil :brief))
(defun mastodon-views--get-instance-url (url username &optional instance)
  "Return an instance base url from a user account URL.
USERNAME is the name to cull.
If INSTANCE is given, use that."
  (cond (instance
         (concat "https://" instance))
        ;; pleroma URL is https://instance.com/users/username
        ((string-suffix-p "users/" (url-basepath url))
         (string-remove-suffix "/users/"
                               (url-basepath url)))
        ;; friendica is https://instance.com/profile/user
        ((string-suffix-p "profile/" (url-basepath url))
         (string-remove-suffix "/profile/"
                               (url-basepath url)))
        ;; mastodon is https://instance.com/@user
        (t
         (string-remove-suffix (concat "/@" username)
                               url))))
(defun mastodon-views--view-instance-description (&optional user brief instance)
  "View the details of the instance the current post's author is on.
USER means to show the instance details for the logged in user.
BRIEF means to show fewer details.
INSTANCE is an instance domain name."
  (interactive)
  (if user
      (let ((response (mastodon-http--get-json
                       (mastodon-http--api "instance")
                       nil ; params
                       nil ; silent
                       :vector)))
        (mastodon-views--instance-response-fun response brief instance))
    (mastodon-tl--do-if-toot
     (let* ((toot (if (mastodon-tl--profile-buffer-p)
                      ;; we may be on profile description itself:
                      (or (mastodon-tl--property 'profile-json)
                          ;; or on profile account listings, which use toot-json:
                          ;; or just toots:
                          (mastodon-tl--property 'toot-json))
                    ;; normal timeline/account listing:
                    (mastodon-tl--property 'toot-json)))
            (reblog (alist-get 'reblog toot))
            (account (or (alist-get 'account reblog)
                         (alist-get 'account toot)
                         toot)) ; else `toot' is already an account listing.
            ;; we can't use --profile-buffer-p as our test here because we may
            ;; be looking at toots/boosts/users in a profile buffer.
            ;; profile-json works as a defacto test for if point is on the
            ;; profile details at the top of a profile buffer.
            (url (if (and (mastodon-tl--profile-buffer-p)
                          ;; only call this in profile buffers:
                          (mastodon-tl--property 'profile-json))
                     (alist-get 'url toot) ; profile description
                   (alist-get 'url account)))
            (username (if (and (mastodon-tl--profile-buffer-p)
                               ;; only call this in profile buffers:
                               (mastodon-tl--property 'profile-json))
                          (alist-get 'username toot) ;; profile
                        (alist-get 'username account)))
            (instance (mastodon-views--get-instance-url url username instance))
            (response (mastodon-http--get-json
                       (if user
                           (mastodon-http--api "instance")
                         (concat instance "/api/v1/instance"))
                       nil ; params
                       nil ; silent
                       :vector)))
       (mastodon-views--instance-response-fun response brief instance)))))
(defun mastodon-views--instance-response-fun (response brief instance)
  "Display instance description RESPONSE in a new buffer.
BRIEF means to show fewer details.
INSTANCE is the instance were are working with."
  (when response
    (let* ((domain (url-file-nondirectory instance))
           (buf (get-buffer-create
                 (format "*mastodon-instance-%s*" domain))))
      (with-mastodon-buffer buf #'special-mode :other-window
        (when brief
          (setq response
                (list (assoc 'uri response)
                      (assoc 'title response)
                      (assoc 'short_description response)
                      (assoc 'email response)
                      (cons 'contact_account
                            (list
                             (assoc 'username
                                    (assoc 'contact_account response))))
                      (assoc 'rules response)
                      (assoc 'stats response))))
        (mastodon-views--print-json-keys response)
        (mastodon-tl--set-buffer-spec (buffer-name buf) "instance" nil)
        (goto-char (point-min))))))
(defun mastodon-views--format-key (el pad)
  "Format a key of element EL, a cons, with PAD padding."
  (format (concat "%-"
                  (number-to-string pad)
                  "s: ")
          (propertize
           (prin1-to-string (car el))
           'face '(:underline t))))
(defun mastodon-views--print-json-keys (response &optional ind)
  "Print the JSON keys and values in RESPONSE.
IND is the optional indentation level to print at."
  (let* ((cars (mapcar
                (lambda (x) (symbol-name (car x)))
                response))
         (pad (1+ (cl-reduce #'max (mapcar #'length cars)))))
    (while response
      (let ((el (pop response)))
        (cond
         ;; vector of alists (fields, instance rules):
         ((and (vectorp (cdr el))
               (not (seq-empty-p (cdr el)))
               (consp (seq-elt (cdr el) 0)))
          (insert
           (mastodon-views--format-key el pad)
           "\n\n")
          (seq-do #'mastodon-views--print-instance-rules-or-fields (cdr el))
          (insert "\n"))
         ;; vector of strings (media types):
         ((and (vectorp (cdr el))
               (not (seq-empty-p (cdr el)))
               (< 1 (seq-length (cdr el)))
               (stringp (seq-elt (cdr el) 0)))
          (when ind (indent-to ind))
          (insert
           (mastodon-views--format-key el pad)
           "\n"
           (seq-mapcat
            (lambda (x) (concat x ", "))
            (cdr el) 'string)
           "\n\n"))
         ;; basic nesting:
         ((consp (cdr el))
          (when ind (indent-to ind))
          (insert
           (mastodon-views--format-key el pad)
           "\n\n")
          (mastodon-views--print-json-keys
           (cdr el) (if ind (+ ind 4) 4)))
         (t
          ;; basic handling of raw booleans:
          (let ((val (cond ((equal (cdr el) ':json-false)
                            "no")
                           ((equal (cdr el) 't)
                            "yes")
                           (t
                            (cdr el)))))
            (when ind (indent-to ind))
            (insert (mastodon-views--format-key el pad)
                    " "
                    (mastodon-views--newline-if-long (cdr el))
                    ;; only send strings straight to --render-text
                    ;; this makes hyperlinks work:
                    (if (not (stringp val))
                        (mastodon-tl--render-text
                         (prin1-to-string val))
                      (mastodon-tl--render-text val))
                    "\n"))))))))
(defun mastodon-views--print-instance-rules-or-fields (alist)
  "Print ALIST of instance rules or contact account or emoji fields."
  (let ((key (or (alist-get 'id alist)
                 (alist-get 'name alist)
                 (alist-get 'shortcode alist)))
        (value (or (alist-get 'text alist)
                   (alist-get 'value alist)
                   (alist-get 'url alist))))
    (indent-to 4)
    (insert
     (format "%-5s: "
             (propertize key
                         'face '(:underline t)))
     (mastodon-views--newline-if-long value)
     (format "%s" (mastodon-tl--render-text
                   value))
     "\n")))
(defun mastodon-views--newline-if-long (el)
  "Return a newline string if the cdr of EL is over 50 characters long."
  (let ((rend (if (stringp el) (mastodon-tl--render-text el) el)))
    (if (and (sequencep rend)
             (< 50 (length rend)))
        "\n"
      "")))
(provide 'mastodon-views)
;;; mastodon-views.el ends here

;;; mastodon-toot.el --- Minor mode for sending Mastodon toots  -*- lexical-binding: t -*-
;; Copyright (C) 2017-2019 Johnson Denen
;; Copyright (C) 2020-2022 Marty Hiatt
;; Author: Johnson Denen <johnson.denen@gmail.com>
;;         Marty Hiatt <martianhiatus@riseup.net>
;; Maintainer: Marty Hiatt <martianhiatus@riseup.net>
;; Version: 1.0.0
;; Homepage: https://codeberg.org/martianh/mastodon.el
;; This file is not part of GNU Emacs.
;; This file is part of mastodon.el.
;; mastodon.el is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; mastodon.el is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with mastodon.el.  If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; mastodon-toot.el supports POSTing status data to Mastodon.
;;; Code:
(eval-when-compile (require 'subr-x))
(require 'emojify nil :noerror)
(declare-function emojify-insert-emoji "emojify")
(declare-function emojify-set-emoji-data "emojify")
(defvar emojify-emojis-dir)
(defvar emojify-user-emojis)
(require 'cl-lib)
(require 'persist)
(require 'mastodon-iso)
(require 'facemenu)
(require 'text-property-search)
(eval-when-compile
  (require 'mastodon-tl))
(defvar mastodon-instance-url)
(defvar mastodon-tl--buffer-spec)
(defvar mastodon-tl--enable-proportional-fonts)
(defvar mastodon-profile-account-settings)
(autoload 'iso8601-parse "iso8601")
(autoload 'mastodon-auth--user-acct "mastodon-auth")
(autoload 'mastodon-http--api "mastodon-http")
(autoload 'mastodon-http--build-array-params-alist "mastodon-http")
(autoload 'mastodon-http--delete "mastodon-http")
(autoload 'mastodon-http--get-json "mastodon-http")
(autoload 'mastodon-http--get-json-async "mastodon-http")
(autoload 'mastodon-http--post "mastodon-http")
(autoload 'mastodon-http--post-media-attachment "mastodon-http")
(autoload 'mastodon-http--process-json "mastodon-http")
(autoload 'mastodon-http--put "mastodon-http")
(autoload 'mastodon-http--read-file-as-string "mastodon-http")
(autoload 'mastodon-http--triage "mastodon-http")
(autoload 'mastodon-profile--fetch-server-account-settings "mastodon-profile")
(autoload 'mastodon-profile--fetch-server-account-settings-maybe "mastodon-profile")
(autoload 'mastodon-profile--get-source-pref "mastodon-profile")
(autoload 'mastodon-profile--show-user "mastodon-profile")
(autoload 'mastodon-profile--update-preference "mastodon-profile")
(autoload 'mastodon-search--search-accounts-query "mastodon-search")
(autoload 'mastodon-search--search-tags-query "mastodon-search")
(autoload 'mastodon-tl--as-string "mastodon-tl")
(autoload 'mastodon-tl--buffer-type-eq "mastodon-tl")
(autoload 'mastodon-tl--clean-tabs-and-nl "mastodon-tl")
(autoload 'mastodon-tl--do-if-toot-strict "mastodon-tl")
(autoload 'mastodon-tl--field "mastodon-tl")
(autoload 'mastodon-tl--find-property-range "mastodon-tl")
(autoload 'mastodon-tl--find-property-range "mastodon-tl")
(autoload 'mastodon-tl--goto-next-toot "mastodon-tl")
(autoload 'mastodon-tl--map-alist "mastodon-tl")
(autoload 'mastodon-tl--property "mastodon-tl")
(autoload 'mastodon-tl--reload-timeline-or-profile "mastodon-tl")
(autoload 'mastodon-tl--render-text "mastodon-tl")
(autoload 'mastodon-tl--set-buffer-spec "mastodon-tl")
(autoload 'mastodon-tl--symbol "mastodon-tl")
(autoload 'mastodon-tl--toot-id "mastodon-tl")
(autoload 'mastodon-toot "mastodon")
(autoload 'mastodon-views--cancel-scheduled-toot "mastodon-views")
(autoload 'mastodon-views--view-scheduled-toots "mastodon-views")
(autoload 'org-read-date "org")
;; for mastodon-toot--translate-toot-text
(autoload 'mastodon-tl--content "mastodon-tl")
(when (require 'lingva nil :no-error)
  (declare-function lingva-translate "lingva"))
(defgroup mastodon-toot nil
  "Tooting in Mastodon."
  :prefix "mastodon-toot-"
  :group 'mastodon)
(defcustom mastodon-toot--default-media-directory "~/"
  "The default directory when prompting for a media file to upload."
  :type 'string)
(defcustom mastodon-toot--attachment-height 80
  "Height of the attached images preview in the toot draft buffer."
  :type 'integer)
(defcustom mastodon-toot--enable-completion t
  "Whether to enable completion of mentions and hashtags.
Used for completion in toot compose buffer."
  :type 'boolean)
(defcustom mastodon-toot--use-company-for-completion nil
  "Whether to enable company for completion.
When non-nil, `company-mode' is enabled in the toot compose
buffer, and mastodon completion backends are added to
`company-capf'.
You need to install company yourself to use this."
  :type 'boolean)
(defcustom mastodon-toot--completion-style-for-mentions "all"
  "The company completion style to use for mentions."
  :type '(choice
          (const :tag "off" nil)
          (const :tag "following only" "following")
          (const :tag "all users" "all")))
(defcustom mastodon-toot-display-orig-in-reply-buffer nil
  "Display a copy of the toot replied to in the compose buffer."
  :type 'boolean)
(defcustom mastodon-toot-orig-in-reply-length 191
  ;; three lines of divider width: (- (* 3 67) (length " Reply to: "))
  "Length to crop toot replied to in the compose buffer to."
  :type 'integer)
(defcustom mastodon-toot--default-reply-visibility "public"
  "Default visibility settings when replying.
If the original toot visibility is different we use the more restricted one."
  :type '(choice
          (const :tag "public" "public")
          (const :tag "unlisted" "unlisted")
          (const :tag "followers only" "private")
          (const :tag "direct" "direct")))
(defcustom mastodon-toot--enable-custom-instance-emoji nil
  "Whether to enable your instance's custom emoji by default."
  :type 'boolean)
(defcustom mastodon-toot--proportional-fonts-compose nil
  "Nonnil to enable using proportional fonts in the compose buffer.
By default fixed width fonts are used."
  :type '(boolean :tag "Enable using proportional rather than fixed \
width fonts"))
(defvar-local mastodon-toot--content-warning nil
  "A flag whether the toot should be marked with a content warning.")
(defvar-local mastodon-toot--content-warning-from-reply-or-redraft nil
  "The content warning of the toot being replied to.")
(defvar-local mastodon-toot--content-nsfw nil
  "A flag indicating whether the toot should be marked as NSFW.")
(defvar mastodon-toot-visibility-list
  '(direct private unlisted public)
  "A list of the available toot visibility settings.")
(defvar-local mastodon-toot--visibility nil
  "A string indicating the visibility of the toot being composed.
Valid values are \"direct\", \"private\" (followers-only),
\"unlisted\", and \"public\".
This is determined by the account setting on the server. To
change the setting on the server, see
`mastodon-toot--set-default-visibility'.")
(defvar-local mastodon-toot--media-attachments nil
  "A list of the media attachments of the toot being composed.")
(defvar-local mastodon-toot--media-attachment-ids nil
  "A list of any media attachment ids of the toot being composed.")
(defvar-local mastodon-toot-poll nil
  "A list of poll options for the toot being composed.")
(defvar-local mastodon-toot--language nil
  "The language of the toot being composed, in ISO 639 (two-letter).")
(defvar-local mastodon-toot--scheduled-for nil
  "An ISO 8601 timestamp that specifying when the post should be published.
Should be at least 5 minutes into the future.")
(defvar-local mastodon-toot--scheduled-id nil
  "The id of the scheduled post that we are now editing.")
(defvar-local mastodon-toot--reply-to-id nil
  "Buffer-local variable to hold the id of the toot being replied to.")
(defvar-local mastodon-toot--edit-toot-id nil
  "The id of the toot being edited.")
(defvar-local mastodon-toot-previous-window-config nil
  "A list of window configuration prior to composing a toot.
Takes its form from `window-configuration-to-register'.")
(defvar mastodon-toot--max-toot-chars nil
  "The maximum allowed characters count for a single toot.")
(defvar-local mastodon-toot-completions nil
  "The data of completion candidates for the current completion at point.")
(defvar mastodon-toot-current-toot-text nil
  "The text of the toot being composed.")
(persist-defvar mastodon-toot-draft-toots-list nil
                "A list of toots that have been saved as drafts.
For the moment we just put all composed toots in here, as we want
to also capture toots that are 'sent' but that don't successfully
send.")
(defvar mastodon-toot-handle-regex
  (rx (| (any ?\( "\n" "\t "" ") bol) ; preceding things
      (group-n 2 (+ ?@ (* (any ?- ?_ ?. "A-Z" "a-z" "0-9" ))) ; handle
               (? ?@ (* (not (any "\n" "\t" " "))))) ; optional domain
      (| "'" word-boundary))) ; boundary or possessive
(defvar mastodon-toot-tag-regex
  (rx (| (any ?\( "\n" "\t" " ") bol)
      (group-n 2 ?# (+ (any "A-Z" "a-z" "0-9")))
      (| "'" word-boundary))) ; boundary or possessive
(defvar mastodon-toot-url-regex
  ;; adapted from ffap-url-regexp
  (concat
   "\\(?2:\\(news\\(post\\)?:\\|mailto:\\|file:\\|\\(ftp\\|https?\\|telnet\\|gopher\\|www\\|wais\\)://\\)" ; uri prefix
   "[^ \n\t]*\\)" ; any old thing that's, i.e. we allow invalid/unwise chars
   "\\b")) ; boundary
(defvar mastodon-toot-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "C-c C-c") #'mastodon-toot--send)
    (define-key map (kbd "C-c C-k") #'mastodon-toot--cancel)
    (define-key map (kbd "C-c C-w") #'mastodon-toot--toggle-warning)
    (define-key map (kbd "C-c C-n") #'mastodon-toot--toggle-nsfw)
    (define-key map (kbd "C-c C-v") #'mastodon-toot--change-visibility)
    (when (require 'emojify nil :noerror)
      (define-key map (kbd "C-c C-e") #'mastodon-toot--insert-emoji))
    (define-key map (kbd "C-c C-a") #'mastodon-toot--attach-media)
    (define-key map (kbd "C-c !") #'mastodon-toot--clear-all-attachments)
    (define-key map (kbd "C-c C-p") #'mastodon-toot--create-poll)
    (define-key map (kbd "C-c C-l") #'mastodon-toot--set-toot-language)
    (define-key map (kbd "C-c C-s") #'mastodon-toot--schedule-toot)
    map)
  "Keymap for `mastodon-toot'.")
(defun mastodon-toot--set-default-visibility ()
  "Set the default visibility for toots on the server."
  (interactive)
  (let ((vis (completing-read "Set default visibility to:"
                              mastodon-toot-visibility-list
                              nil t)))
    (mastodon-profile--update-preference "privacy" vis :source)))
(defun mastodon-toot--get-max-toot-chars (&optional no-toot)
  "Fetch max_toot_chars from `mastodon-instance-url' asynchronously.
NO-TOOT means we are not calling from a toot buffer."
  (mastodon-http--get-json-async
   (mastodon-http--api "instance")
   nil
   'mastodon-toot--get-max-toot-chars-callback no-toot))
(defun mastodon-toot--get-max-toot-chars-callback (json-response
                                                   &optional no-toot)
  "Set max_toot_chars returned in JSON-RESPONSE and display in new toot buffer.
NO-TOOT means we are not calling from a toot buffer."
  (let ((max-chars
         (or
          (alist-get 'max_toot_chars json-response)
          ;; some servers have this instead:
          (alist-get 'max_characters
                     (alist-get 'statuses
                                (alist-get 'configuration
                                           json-response))))))
    (setq mastodon-toot--max-toot-chars max-chars)
    (unless no-toot
      (with-current-buffer "*new toot*"
        (mastodon-toot--update-status-fields)))))
(defun mastodon-toot--action-success (marker byline-region remove)
  "Insert/remove the text MARKER with `success' face in byline.
BYLINE-REGION is a cons of start and end pos of the byline to be
modified.
Remove MARKER if REMOVE is non-nil, otherwise add it."
  (let ((inhibit-read-only t)
        (bol (car byline-region))
        (eol (cdr byline-region))
        (at-byline-p (eq (mastodon-tl--property 'byline :no-move) t)))
    (save-excursion
      (when remove
        (goto-char bol)
        (beginning-of-line) ;; The marker is not part of the byline
        (if (search-forward (format "(%s) " marker) eol t)
            (replace-match "")
          (message "Oops: could not find marker '(%s)'" marker)))
      (unless remove
        (goto-char bol)
        (insert (format "(%s) "
                        (propertize marker 'face 'success)))))
    (when at-byline-p
      ;; leave point after the marker:
      (unless remove
        ;; if point is inside the byline, back up first so
        ;; we don't move to the following toot:
        (beginning-of-line)
        (forward-line -1)
        (mastodon-tl--goto-next-toot)))))
(defun mastodon-toot--action (action callback)
  "Take ACTION on toot at point, then execute CALLBACK.
Makes a POST request to the server. Used for favouriting,
boosting, or bookmarking toots."
  (let* ((id (mastodon-tl--property 'base-toot-id))
         (url (mastodon-http--api (concat "statuses/"
                                          (mastodon-tl--as-string id)
                                          "/"
                                          action))))
    (let ((response (mastodon-http--post url)))
      (mastodon-http--triage response callback))))
(defun mastodon-toot--toggle-boost-or-favourite (type)
  "Toggle boost or favourite of toot at `point'.
TYPE is a symbol, either `favourite' or `boost.'"
  (mastodon-tl--do-if-toot-strict
   (let* ((boost-p (equal type 'boost))
          (has-id (mastodon-tl--property 'base-toot-id))
          (byline-region (when has-id
                           (mastodon-tl--find-property-range 'byline (point))))
          (id (when byline-region
                (mastodon-tl--as-string (mastodon-tl--property 'base-toot-id))))
          (boosted (when byline-region
                     (get-text-property (car byline-region) 'boosted-p)))
          (faved (when byline-region
                   (get-text-property (car byline-region) 'favourited-p)))
          (action (if boost-p
                      (if boosted "unreblog" "reblog")
                    (if faved "unfavourite" "favourite")))
          (msg (if boosted "unboosted" "boosted"))
          (action-string (if boost-p "boost" "favourite"))
          (remove (if boost-p (when boosted t) (when faved t)))
          (toot-type (alist-get 'type (mastodon-tl--property 'toot-json)))
          (visibility (mastodon-tl--field 'visibility
                                          (mastodon-tl--property 'toot-json))))
     (if byline-region
         (if (and (or (equal visibility "direct")
                      (equal visibility "private"))
                  boost-p)
             (message "You cant boost posts with visibility: %s" visibility)
           (cond ;; actually there's nothing wrong with faving/boosting own toots!
            ;;((mastodon-toot--own-toot-p (mastodon-tl--property 'toot-json))
            ;;(error "You can't %s your own toots" action-string))
            ;; & nothing wrong with faving/boosting own toots from notifs:
            ;; this boosts/faves the base toot, not the notif status
            ((and (equal "reblog" toot-type)
                  (not (mastodon-tl--buffer-type-eq 'notifications)))
             (error "You can't %s boosts" action-string))
            ((and (equal "favourite" toot-type)
                  (not (mastodon-tl--buffer-type-eq 'notifications)))
             (error "You can't %s favourites" action-string))
            ((and (equal "private" visibility)
                  (equal type 'boost))
             (error "You can't boost private toots"))
            (t
             (mastodon-toot--action
              action
              (lambda ()
                (let ((inhibit-read-only t))
                  (add-text-properties (car byline-region)
                                       (cdr byline-region)
                                       (if boost-p
                                           (list 'boosted-p (not boosted))
                                         (list 'favourited-p (not faved))))
                  (mastodon-toot--update-stats-on-action type remove)
                  (mastodon-toot--action-success
                   (if boost-p
                       (mastodon-tl--symbol 'boost)
                     (mastodon-tl--symbol 'favourite))
                   byline-region remove))
                (message (format "%s #%s" (if boost-p msg action) id)))))))
       (message (format "Nothing to %s here?!?" action-string))))))
(defun mastodon-toot--inc-or-dec (count subtract)
  "If SUBTRACT, decrement COUNT, else increment."
  (if subtract
      (1- count)
    (1+ count)))
(defun mastodon-toot--update-stats-on-action (action &optional subtract)
  "Increment the toot stats display upon ACTION.
ACTION is a symbol, either `favourite' or `boost'.
SUBTRACT means we are un-favouriting or unboosting, so we decrement."
  (let* ((count-prop (if (eq action 'favourite)
                         'favourites-count
                       'boosts-count))
         (count-prop-range (mastodon-tl--find-property-range count-prop (point)))
         (count (get-text-property (car count-prop-range) count-prop))
         (inhibit-read-only 1))
    ;; TODO another way to implement this would be to async fetch counts again
    ;;  and re-display from count-properties
    (add-text-properties
     (car count-prop-range)
     (cdr count-prop-range)
     (list 'display ; update the display prop:
           (number-to-string
            (mastodon-toot--inc-or-dec count subtract))
           ;; update the count prop
           ;; we rely on this for any subsequent actions:
           count-prop
           (mastodon-toot--inc-or-dec count subtract)))))
(defun mastodon-toot--toggle-boost ()
  "Boost/unboost toot at `point'."
  (interactive)
  (mastodon-toot--toggle-boost-or-favourite 'boost))
(defun mastodon-toot--toggle-favourite ()
  "Favourite/unfavourite toot at `point'."
  (interactive)
  (mastodon-toot--toggle-boost-or-favourite 'favourite))
;; TODO maybe refactor into boost/fave fun
(defun mastodon-toot--toggle-bookmark ()
  "Bookmark or unbookmark toot at point."
  (interactive)
  (mastodon-tl--do-if-toot-strict
   (let* ( ;(toot (mastodon-tl--property 'toot-json))
          (id (mastodon-tl--property 'base-toot-id))
          ;; (mastodon-tl--as-string (mastodon-tl--toot-id toot)))
          (bookmarked-p (mastodon-tl--property 'bookmarked-p))
          (prompt (if bookmarked-p
                      (format "Toot already bookmarked. Remove? ")
                    (format "Bookmark this toot? ")))
          (byline-region
           (when id
             (mastodon-tl--find-property-range 'byline (point))))
          (action (if bookmarked-p "unbookmark" "bookmark"))
          (bookmark-str (mastodon-tl--symbol 'bookmark))
          (message (if bookmarked-p
                       "Bookmark removed!"
                     "Toot bookmarked!"))
          (remove (when bookmarked-p t)))
     (if byline-region
         (when (y-or-n-p prompt)
           (mastodon-toot--action
            action
            (lambda ()
              (let ((inhibit-read-only t))
                (add-text-properties (car byline-region)
                                     (cdr byline-region)
                                     (list 'bookmarked-p (not bookmarked-p))))
              (mastodon-toot--action-success
               bookmark-str
               byline-region remove)
              (message (format "%s #%s" message id)))))
       (message (format "Nothing to %s here?!?" action))))))
(defun mastodon-toot--list-toot-boosters ()
  "List the boosters of toot at point."
  (interactive)
  (mastodon-toot--list-toot-boosters-or-favers))
(defun mastodon-toot--list-toot-favouriters ()
  "List the favouriters of toot at point."
  (interactive)
  (mastodon-toot--list-toot-boosters-or-favers :favourite))
(defun mastodon-toot--list-toot-boosters-or-favers (&optional favourite)
  "List the favouriters or boosters of toot at point.
With FAVOURITE, list favouriters, else list boosters."
  (mastodon-tl--do-if-toot-strict
   (let* ((base-toot (mastodon-tl--property 'base-toot-id))
          (endpoint (if favourite "favourited_by" "reblogged_by"))
          (url (mastodon-http--api
                (format "statuses/%s/%s" base-toot endpoint)))
          (params '(("limit" . "80")))
          (json (mastodon-http--get-json url params)))
     (if (eq (caar json) 'error)
         (error "%s (Status does not exist or is private)"
                (alist-get 'error json))
       (let ((handles (mastodon-tl--map-alist 'acct json))
             (type-string (if favourite "Favouriters" "Boosters")))
         (if (not handles)
             (error "Looks like this toot has no %s" type-string)
           (let ((choice
                  (completing-read
                   (format "%s (enter to view profile): " type-string)
                   handles
                   nil
                   t)))
             (mastodon-profile--show-user choice))))))))
(defun mastodon-toot--copy-toot-url ()
  "Copy URL of toot at point.
If the toot is a fave/boost notification, copy the URL of the
base toot."
  (interactive)
  (let* ((toot (or (mastodon-tl--property 'base-toot)
                   (mastodon-tl--property 'toot-json)))
         (url (if (mastodon-tl--field 'reblog toot)
                  (alist-get 'url (alist-get 'reblog toot))
                (alist-get 'url toot))))
    (kill-new url)
    (message "Toot URL copied to the clipboard.")))
(defun mastodon-toot--copy-toot-text ()
  "Copy text of toot at point.
If the toot is a fave/boost notification, copy the text of the
base toot."
  (interactive)
  (let* ((toot (or (mastodon-tl--property 'base-toot)
                   (mastodon-tl--property 'toot-json))))
    (kill-new (mastodon-tl--content toot))
    (message "Toot content copied to the clipboard.")))
;; (when (require 'lingva nil :no-error)
(defun mastodon-toot--translate-toot-text ()
  "Translate text of toot at point.
Uses `lingva.el'."
  (interactive)
  (if (not (require 'lingva nil :no-error))
      (message "Looks like you need to install lingva.el first.")
    (if mastodon-tl--buffer-spec
        (let ((toot (mastodon-tl--property 'toot-json)))
          (if toot
              (lingva-translate nil
                                (mastodon-tl--content toot)
                                (when mastodon-tl--enable-proportional-fonts
                                  t))
            (message "No toot to translate?")))
      (message "No mastodon buffer?"))))
(defun mastodon-toot--own-toot-p (toot)
  "Check if TOOT is user's own, e.g. for deleting it."
  (and (not (alist-get 'reblog toot))
       (equal (alist-get 'acct (alist-get 'account toot))
              (mastodon-auth--user-acct))))
(defun mastodon-toot--pin-toot-toggle ()
  "Pin or unpin user's toot at point."
  (interactive)
  (let* ((toot (or (mastodon-tl--property 'base-toot) ;fave/boost notifs
                   (mastodon-tl--property 'toot-json)))
         (pinnable-p (mastodon-toot--own-toot-p toot))
         (pinned-p (equal (alist-get 'pinned toot) t))
         (action (if pinned-p "unpin" "pin"))
         (msg (if pinned-p "unpinned" "pinned"))
         (msg-y-or-n (if pinned-p "Unpin" "Pin")))
    (if (not pinnable-p)
        (message "You can only pin your own toots.")
      (when (y-or-n-p (format "%s this toot? " msg-y-or-n))
        (mastodon-toot--action action
                               (lambda ()
                                 (when mastodon-tl--buffer-spec
                                   (mastodon-tl--reload-timeline-or-profile))
                                 (message "Toot %s!" msg)))))))
(defun mastodon-toot--delete-toot ()
  "Delete user's toot at point synchronously."
  (interactive)
  (mastodon-toot--delete-and-redraft-toot t))
;; TODO: handle media/poll for redrafting toots
(defun mastodon-toot--delete-and-redraft-toot (&optional no-redraft)
  "Delete and redraft user's toot at point synchronously.
NO-REDRAFT means delete toot only."
  (interactive)
  (let* ((toot (or (mastodon-tl--property 'base-toot) ;fave/boost notifs
                   (mastodon-tl--property 'toot-json)))
         (id (mastodon-tl--as-string (mastodon-tl--toot-id toot)))
         (url (mastodon-http--api (format "statuses/%s" id)))
         (toot-cw (alist-get 'spoiler_text toot))
         (toot-visibility (alist-get 'visibility toot))
         (reply-id (alist-get 'in_reply_to_id toot))
         (pos (point)))
    (if (not (mastodon-toot--own-toot-p toot))
        (message "You can only delete (and redraft) your own toots.")
      (when (y-or-n-p (if no-redraft
                          (format "Delete this toot? ")
                        (format "Delete and redraft this toot? ")))
        (let* ((response (mastodon-http--delete url)))
          (mastodon-http--triage
           response
           (lambda ()
             (if no-redraft
                 (progn
                   (when mastodon-tl--buffer-spec
                     (mastodon-tl--reload-timeline-or-profile pos))
                   (message "Toot deleted!"))
               (mastodon-toot--redraft response
                                       reply-id
                                       toot-visibility
                                       toot-cw)))))))))
(defun mastodon-toot--set-cw (&optional cw)
  "Set content warning to CW if it is non-nil."
  (unless (or (null cw) ; cw is nil for `mastodon-tl--dm-user'
              (string-empty-p cw))
    (setq mastodon-toot--content-warning t)
    (setq mastodon-toot--content-warning-from-reply-or-redraft cw)))
(defun mastodon-toot--redraft (response &optional reply-id toot-visibility toot-cw)
  "Opens a new toot compose buffer using values from RESPONSE buffer.
REPLY-ID, TOOT-VISIBILITY, and TOOT-CW of deleted toot are preseved."
  (with-current-buffer response
    (let* ((json-response (mastodon-http--process-json))
           (content (alist-get 'text json-response)))
      (mastodon-toot--compose-buffer)
      (goto-char (point-max))
      (insert content)
      ;; adopt reply-to-id, visibility and CW from deleted toot:
      (mastodon-toot--set-toot-properties
       reply-id toot-visibility toot-cw
       ;; TODO set new lang/scheduled props here
       nil))))
(defun mastodon-toot--set-toot-properties (reply-id visibility cw lang
                                                    &optional scheduled
                                                    scheduled-id)
  "Set the toot properties for the current redrafted or edited toot.
REPLY-ID, VISIBILITY, CW, SCHEDULED, and LANG are the properties to set."
  (when reply-id
    (setq mastodon-toot--reply-to-id reply-id))
  (setq mastodon-toot--visibility visibility)
  (setq mastodon-toot--scheduled-for scheduled)
  (setq mastodon-toot--scheduled-id scheduled-id)
  (when (not (string-empty-p lang))
    (setq mastodon-toot--language lang))
  (mastodon-toot--set-cw cw)
  (mastodon-toot--update-status-fields))
(defun mastodon-toot--kill (&optional cancel)
  "Kill `mastodon-toot-mode' buffer and window.
CANCEL means the toot was not sent, so we save the toot text as a draft."
  (let ((prev-window-config mastodon-toot-previous-window-config))
    (unless (eq mastodon-toot-current-toot-text nil)
      (when cancel
        (cl-pushnew mastodon-toot-current-toot-text
                    mastodon-toot-draft-toots-list :test 'equal)))
    ;; prevent some weird bug when cancelling a non-empty toot:
    (delete #'mastodon-toot--save-toot-text after-change-functions)
    (kill-buffer-and-window)
    (mastodon-toot--restore-previous-window-config prev-window-config)))
(defun mastodon-toot--cancel ()
  "Kill new-toot buffer/window. Does not POST content to Mastodon.
If toot is not empty, prompt to save text as a draft."
  (interactive)
  (if (mastodon-toot--empty-p)
      (mastodon-toot--kill)
    (when (y-or-n-p "Save draft toot?")
      (mastodon-toot--save-draft))
    (mastodon-toot--kill)))
(defun mastodon-toot--save-draft ()
  "Save the current compose toot text as a draft.
Pushes `mastodon-toot-current-toot-text' to
`mastodon-toot-draft-toots-list'."
  (interactive)
  (unless (eq mastodon-toot-current-toot-text nil)
    (cl-pushnew mastodon-toot-current-toot-text
                mastodon-toot-draft-toots-list :test 'equal)
    (message "Draft saved!")))
(defun mastodon-toot--empty-p (&optional text-only)
  "Return t if toot has no text, attachments, or polls.
TEXT-ONLY means don't check for attachments or polls."
  (and (if text-only
           t
         (not mastodon-toot--media-attachments)
         (not mastodon-toot-poll))
       (string-empty-p (mastodon-tl--clean-tabs-and-nl
                        (mastodon-toot--remove-docs)))))
(defalias 'mastodon-toot--insert-emoji
  'emojify-insert-emoji
  "Prompt to insert an emoji.")
(defun mastodon-toot--download-custom-emoji ()
  "Download `mastodon-instance-url's custom emoji.
Emoji images are stored in a subdir of `emojify-emojis-dir'.
To use the downloaded emoji, run `mastodon-toot--enable-custom-emoji'."
  (interactive)
  (let ((custom-emoji (mastodon-http--get-json
                       (mastodon-http--api "custom_emojis")))
        (mastodon-custom-emoji-dir (file-name-as-directory
                                    (concat (file-name-as-directory
                                             (expand-file-name
                                              emojify-emojis-dir))
                                            "mastodon-custom-emojis"))))
    (if (not (file-directory-p emojify-emojis-dir))
        (message "Looks like you need to set up emojify first.")
      (unless (file-directory-p mastodon-custom-emoji-dir)
        (make-directory mastodon-custom-emoji-dir nil)) ; no add parent
      (mapc (lambda (x)
              (let ((url (alist-get 'url x))
                    (shortcode (alist-get 'shortcode x)))
                ;; skip anything that contains unexpected characters
                (when (and url shortcode
                           (string-match-p "^[a-zA-Z0-9-_]+$" shortcode)
                           (string-match-p "^[a-zA-Z]+$" (file-name-extension url)))
                  (url-copy-file url
                                 (concat
                                  mastodon-custom-emoji-dir
                                  shortcode
                                  "."
                                  (file-name-extension url))
                                 t))))
            custom-emoji)
      (message "Custom emoji for %s downloaded to %s"
               mastodon-instance-url
               mastodon-custom-emoji-dir))))
(defun mastodon-toot--collect-custom-emoji ()
  "Return a list of `mastodon-instance-url's custom emoji.
The list is formatted for `emojify-user-emojis', which see."
  (let* ((mastodon-custom-emojis-dir (concat (expand-file-name
                                              emojify-emojis-dir)
                                             "/mastodon-custom-emojis/"))
         (custom-emoji-files (directory-files mastodon-custom-emojis-dir
                                              nil ; not full path
                                              "^[^.]")) ; no dot files
         (mastodon-emojify-user-emojis))
    (mapc (lambda (x)
            (push
             `(,(concat ":"
                        (file-name-base x) ":")
               . (("name" . ,(file-name-base x))
                  ("image" . ,(concat mastodon-custom-emojis-dir x))
                  ("style" . "github")))
             mastodon-emojify-user-emojis))
          custom-emoji-files)
    (reverse mastodon-emojify-user-emojis)))
(defun mastodon-toot--enable-custom-emoji ()
  "Add `mastodon-instance-url's custom emoji to `emojify'.
Custom emoji must first be downloaded with
`mastodon-toot--download-custom-emoji'. Custom emoji are appended
to `emojify-user-emojis', and the emoji data is updated."
  (interactive)
  (unless (file-exists-p (concat (expand-file-name
                                  emojify-emojis-dir)
                                 "/mastodon-custom-emojis/"))
    (when (y-or-n-p "Looks like you haven't downloaded your
    instance's custom emoji yet. Download now? ")
      (mastodon-toot--download-custom-emoji)))
  (setq emojify-user-emojis
        (append (mastodon-toot--collect-custom-emoji)
                emojify-user-emojis))
  ;; if already loaded, reload
  (when (featurep 'emojify)
    (emojify-set-emoji-data)))
(defun mastodon-toot--remove-docs ()
  "Get the body of a toot from the current compose buffer."
  (let ((header-region (mastodon-tl--find-property-range 'toot-post-header
                                                         (point-min))))
    (buffer-substring (cdr header-region) (point-max))))
(defun mastodon-toot--build-poll-params ()
  "Return an alist of parameters for POSTing a poll status."
  (append
   (mastodon-http--build-array-params-alist
    "poll[options][]"
    (plist-get mastodon-toot-poll :options))
   `(("poll[expires_in]" .  ,(plist-get mastodon-toot-poll :expiry)))
   `(("poll[multiple]" . ,(symbol-name (plist-get mastodon-toot-poll :multi))))
   `(("poll[hide_totals]" . ,(symbol-name (plist-get mastodon-toot-poll :hide))))))
(defun mastodon-toot--read-cw-string ()
  "Read a content warning from the minibuffer."
  (when (and (not (mastodon-toot--empty-p))
             mastodon-toot--content-warning)
    (read-string "Warning: "
                 mastodon-toot--content-warning-from-reply-or-redraft)))
(defun mastodon-toot--send ()
  "POST contents of new-toot buffer to Mastodon instance and kill buffer.
If media items have been attached and uploaded with
`mastodon-toot--attach-media', they are attached to the toot.
If `mastodon-toot--edit-toot-id' is non-nil, PUT contents to
instance to edit a toot."
  (interactive)
  (let* ((toot (mastodon-toot--remove-docs))
         (scheduled mastodon-toot--scheduled-for)
         (scheduled-id mastodon-toot--scheduled-id)
         (edit-id mastodon-toot--edit-toot-id)
         (endpoint
          (if edit-id
              ;; we are sending an edit:
              (mastodon-http--api (format "statuses/%s"
                                          edit-id))
            (mastodon-http--api "statuses")))
         (cw (mastodon-toot--read-cw-string))
         (args-no-media (append `(("status" . ,toot)
                                  ("in_reply_to_id" . ,mastodon-toot--reply-to-id)
                                  ("visibility" . ,mastodon-toot--visibility)
                                  ("sensitive" . ,(when mastodon-toot--content-nsfw
                                                    (symbol-name t)))
                                  ("spoiler_text" . ,cw)
                                  ("language" . ,mastodon-toot--language))
                                ;; Pleroma instances can't handle null-valued
                                ;; scheduled_at args, so only add if non-nil
                                (when scheduled `(("scheduled_at" . ,scheduled)))))
         (args-media (when mastodon-toot--media-attachments
                       (mastodon-http--build-array-params-alist
                        "media_ids[]"
                        mastodon-toot--media-attachment-ids)))
         (args-poll (when mastodon-toot-poll
                      (mastodon-toot--build-poll-params)))
         ;; media || polls:
         (args (if mastodon-toot--media-attachments
                   (append args-media args-no-media)
                 (if mastodon-toot-poll
                     (append args-no-media args-poll)
                   args-no-media)))
         (prev-window-config mastodon-toot-previous-window-config))
    (cond ((and mastodon-toot--media-attachments
                ;; make sure we have media args
                ;; and the same num of ids as attachments
                (or (not args-media)
                    (not (= (length mastodon-toot--media-attachments)
                            (length mastodon-toot--media-attachment-ids)))))
           (message "Something is wrong with your uploads. Wait for them to complete or try again."))
          ((and mastodon-toot--max-toot-chars
                (> (mastodon-toot--count-toot-chars toot cw) mastodon-toot--max-toot-chars))
           (message "Looks like your toot (inc. CW) is longer than that maximum allowed length."))
          ((mastodon-toot--empty-p)
           (message "Empty toot. Cowardly refusing to post this."))
          (t
           (let ((response (if edit-id
                               ;; we are sending an edit:
                               (mastodon-http--put endpoint args)
                             (mastodon-http--post endpoint args))))
             (mastodon-http--triage
              response
              (lambda ()
                (mastodon-toot--kill)
                (if scheduled
                    (message "Toot scheduled!")
                  (message "Toot toot!"))
                ;; cancel scheduled toot if we were editing it:
                (when scheduled-id
                  (mastodon-views--cancel-scheduled-toot
                   scheduled-id :no-confirm))
                (mastodon-toot--restore-previous-window-config prev-window-config)
                (when edit-id
                  (let ((pos (marker-position (cadr prev-window-config))))
                    (mastodon-tl--reload-timeline-or-profile pos))))))))))
;; EDITING TOOTS:
(defun mastodon-toot--edit-toot-at-point ()
  "Edit the user's toot at point."
  (interactive)
  (let ((toot (or (mastodon-tl--property 'base-toot); fave/boost notifs
                  (mastodon-tl--property 'toot-json))))
    (if (not (mastodon-toot--own-toot-p toot))
        (message "You can only edit your own toots.")
      (let* ((id (mastodon-tl--as-string (mastodon-tl--toot-id toot)))
             (source (mastodon-toot--get-toot-source id))
             (content (alist-get 'text source))
             (source-cw (alist-get 'spoiler_text source))
             (toot-visibility (alist-get 'visibility toot))
             (toot-language (alist-get 'language toot))
             (reply-id (alist-get 'in_reply_to_id toot)))
        (when (y-or-n-p "Edit this toot? ")
          (mastodon-toot--compose-buffer nil reply-id nil content :edit)
          (goto-char (point-max))
          ;; (insert content)
          ;; adopt reply-to-id, visibility, CW, and language:
          (mastodon-toot--set-toot-properties reply-id toot-visibility
                                              source-cw toot-language)
          (mastodon-toot--update-status-fields)
          (setq mastodon-toot--edit-toot-id id))))))
(defun mastodon-toot--get-toot-source (id)
  "Fetch the source JSON of toot with ID."
  (let ((url (mastodon-http--api (format "/statuses/%s/source" id))))
    (mastodon-http--get-json url nil :silent)))
(defun mastodon-toot--get-toot-edits (id)
  "Return the edit history of toot with ID."
  (let* ((url (mastodon-http--api (format "statuses/%s/history" id))))
    (mastodon-http--get-json url)))
(defun mastodon-toot--view-toot-edits ()
  "View editing history of the toot at point in a popup buffer."
  (interactive)
  (let ((id (mastodon-tl--property 'base-toot-id))
        (history (mastodon-tl--property 'edit-history))
        (buf "*mastodon-toot-edits*"))
    (with-mastodon-buffer buf #'special-mode :other-window
      (let ((count 1))
        (mapc (lambda (x)
                (insert (propertize (if (= count 1)
                                        (format "%s [original]:\n" count)
                                      (format "%s:\n" count))
                                    'face font-lock-comment-face)
                        (mastodon-toot--insert-toot-iter x)
                        "\n")
                (cl-incf count))
              history))
      (setq-local header-line-format
                  (propertize
                   (format "Edits to toot by %s:"
                           (alist-get 'username
                                      (alist-get 'account (car history))))
                   'face font-lock-comment-face))
      (mastodon-tl--set-buffer-spec (buffer-name (current-buffer))
                                    (format "statuses/%s/history" id)
                                    nil))))
(defun mastodon-toot--insert-toot-iter (it)
  "Insert iteration IT of toot."
  (let ((content (alist-get 'content it)))
    ;; (account (alist-get 'account it))
    ;; TODO: handle polls, media
    (mastodon-tl--render-text content)))
(defun mastodon-toot--restore-previous-window-config (config)
  "Restore the window CONFIG after killing the toot compose buffer.
Buffer-local variable `mastodon-toot-previous-window-config' holds the config."
  (set-window-configuration (car config))
  (goto-char (cadr config)))
(defun mastodon-toot--mentions-to-string (mentions)
  "Apply `mastodon-toot--process-local' function to each mention in MENTIONS.
Remove empty string (self) from result and joins the sequence with whitespace."
  (mapconcat (lambda (mention) mention)
	     (remove "" (mapcar #'mastodon-toot--process-local mentions))
             " "))
(defun mastodon-toot--process-local (acct)
  "Add domain to local ACCT and replace the curent user name with \"\".
Mastodon requires the full @user@domain, even in the case of local accts.
eg. \"user\" -> \"@user@local.social\" (when local.social is the domain of the
mastodon-instance-url).
eg. \"yourusername\" -> \"\"
eg. \"feduser@fed.social\" -> \"@feduser@fed.social\"."
  (cond ((string-match-p "@" acct) (concat "@" acct)) ; federated acct
        ((string= (mastodon-auth--user-acct) acct) "") ; your acct
        (t (concat "@" acct "@" ; local acct
                   (cadr (split-string mastodon-instance-url "/" t))))))
(defun mastodon-toot--mentions (status)
  "Extract mentions (not the reply-to author or booster) from STATUS.
The mentioned users look like this:
Local user (including the logged in): `username`.
Federated user: `username@host.co`."
  (let* ((boosted (mastodon-tl--field 'reblog status))
         (mentions
          (if boosted
	      (alist-get 'mentions (alist-get 'reblog status))
	    (alist-get 'mentions status))))
    ;; reverse does not work on vectors in 24.5
    (mastodon-tl--map-alist 'acct (reverse mentions))))
(defun mastodon-toot--get-bounds (regex)
  "Get bounds of tag or handle before point using REGEX."
  ;; needed because # and @ are not part of any existing thing at point
  (save-match-data
    (save-excursion
      ;; match full handle inc. domain, or tag including #
      ;; (see the regexes for subexp 2)
      (when (re-search-backward regex
                                (save-excursion
                                  (forward-whitespace -1)
                                  (point))
                                :no-error)
        (cons (match-beginning 2)
              (match-end 2))))))
(defun mastodon-toot--fetch-completion-candidates (start end &optional tags)
  "Search for a completion prefix from buffer positions START to END.
Return a list of candidates.
If TAGS, we search for tags, else we search for handles."
  ;; we can't save the first two-letter search then only filter the
  ;; resulting list, as max results returned is 40.
  (setq mastodon-toot-completions
        (if tags
            (let ((tags-list (mastodon-search--search-tags-query
                              (buffer-substring-no-properties start end))))
              (cl-loop for tag in tags-list
                       collect (cons (concat "#" (car tag))
                                     (cdr tag))))
          (mastodon-search--search-accounts-query
           (buffer-substring-no-properties start end)))))
(defun mastodon-toot--mentions-capf ()
  "Build a mentions completion backend for `completion-at-point-functions'."
  (let* ((bounds
          (mastodon-toot--get-bounds mastodon-toot-handle-regex))
         (start (car bounds))
         (end (cdr bounds)))
    (when bounds
      (list start
            end
            ;; only search when necessary:
            (completion-table-dynamic
             (lambda (_)
               ;; Interruptible candidate computation
               ;; suggestion from minad (d mendler), thanks!
               (let ((result
                      (while-no-input
                        (mastodon-toot--fetch-completion-candidates start end))))
                 (and (consp result) result))))
            :exclusive 'no
            :annotation-function
            (lambda (candidate)
              (concat " "
                      (mastodon-toot--mentions-annotation-fun candidate)))))))
(defun mastodon-toot--tags-capf ()
  "Build a tags completion backend for `completion-at-point-functions'."
  (let* ((bounds
          (mastodon-toot--get-bounds mastodon-toot-tag-regex))
         (start (car bounds))
         (end (cdr bounds)))
    (when bounds
      (list start
            end
            ;; only search when necessary:
            (completion-table-dynamic
             (lambda (_)
               ;; Interruptible candidate computation
               ;; suggestion from minad (d mendler), thanks!
               (let ((result
                      (while-no-input
                        (mastodon-toot--fetch-completion-candidates start end :tags))))
                 (and (consp result) result))))
            :exclusive 'no
            :annotation-function
            (lambda (candidate)
              (concat " "
                      (mastodon-toot--tags-annotation-fun candidate)))))))
(defun mastodon-toot--mentions-annotation-fun (candidate)
  "Given a handle completion CANDIDATE, return its annotation string, a username."
  (caddr (assoc candidate mastodon-toot-completions)))
(defun mastodon-toot--tags-annotation-fun (candidate)
  "Given a tag string CANDIDATE, return an annotation, the tag's URL."
  ;; FIXME check the list returned here? should be cadr
  ;;or make it an alist and use cdr
  (cadr (assoc candidate mastodon-toot-completions)))
(defun mastodon-toot--reply ()
  "Reply to toot at `point'.
Customize `mastodon-toot-display-orig-in-reply-buffer' to display
text of the toot being replied to in the compose buffer."
  (interactive)
  (mastodon-tl--do-if-toot-strict
   (let* ((toot (mastodon-tl--property 'toot-json))
          ;; no-move arg for base toot, because if it doesn't have one, it is
          ;; fetched from next toot!
          (base-toot (mastodon-tl--property 'base-toot :no-move)) ; for new notifs handling
          (id (mastodon-tl--as-string (mastodon-tl--field 'id (or base-toot toot))))
          (account (mastodon-tl--field 'account toot))
          (user (alist-get 'acct account))
          (mentions (mastodon-toot--mentions (or base-toot toot)))
          (boosted (mastodon-tl--field 'reblog (or base-toot toot)))
          (booster (when boosted
                     (alist-get 'acct
                                (alist-get 'account toot)))))
     (mastodon-toot
      (when user
        (if booster
            (if (and (not (equal user booster))
                     (not (member booster mentions)))
                ;; different booster, user and mentions:
		(mastodon-toot--mentions-to-string (append (list user booster) mentions nil))
              ;; booster is either user or in mentions:
              (if (not (member user mentions))
                  ;; user not already in mentions:
		  (mastodon-toot--mentions-to-string (append (list user) mentions nil))
                ;; user already in mentions:
                (mastodon-toot--mentions-to-string (copy-sequence mentions))))
          ;; ELSE no booster:
          (if (not (member user mentions))
              ;; user not in mentions:
	      (mastodon-toot--mentions-to-string (append (list user) mentions nil))
            ;; user in mentions already:
            (mastodon-toot--mentions-to-string (copy-sequence mentions)))))
      id
      (or base-toot toot)))))
(defun mastodon-toot--toggle-warning ()
  "Toggle `mastodon-toot--content-warning'."
  (interactive)
  (setq mastodon-toot--content-warning
        (not mastodon-toot--content-warning))
  (mastodon-toot--update-status-fields))
(defun mastodon-toot--toggle-nsfw ()
  "Toggle `mastodon-toot--content-nsfw'."
  (interactive)
  (setq mastodon-toot--content-nsfw
        (not mastodon-toot--content-nsfw))
  (message "NSFW flag is now %s" (if mastodon-toot--content-nsfw "on" "off"))
  (mastodon-toot--update-status-fields))
(defun mastodon-toot--change-visibility ()
  "Change the current visibility to the next valid value."
  (interactive)
  (if (mastodon-tl--buffer-type-eq 'edit-toot)
      (message "You can't change visibility when editing toots.")
    (setq mastodon-toot--visibility
          (cond ((string= mastodon-toot--visibility "public")
                 "unlisted")
                ((string= mastodon-toot--visibility "unlisted")
                 "private")
                ((string= mastodon-toot--visibility "private")
                 "direct")
                (t
                 "public")))
    (mastodon-toot--update-status-fields)))
(defun mastodon-toot--clear-all-attachments ()
  "Remove all attachments from a toot draft."
  (interactive)
  (setq mastodon-toot--media-attachments nil)
  (setq mastodon-toot--media-attachment-ids nil)
  (mastodon-toot--refresh-attachments-display)
  (mastodon-toot--update-status-fields))
(defun mastodon-toot--attach-media (file description)
  "Prompt for an attachment FILE with DESCRIPTION.
A preview is displayed in the new toot buffer, and the file
is uploaded asynchronously using `mastodon-toot--upload-attached-media'.
File is actually attached to the toot upon posting."
  (interactive "fFilename: \nsDescription: ")
  (when (>= (length mastodon-toot--media-attachments) 4)
    ;; Only a max. of 4 attachments are allowed, so pop the oldest one.
    (pop mastodon-toot--media-attachments))
  (if (file-directory-p file)
      (message "Looks like you chose a directory not a file.")
    (setq mastodon-toot--media-attachments
          (nconc mastodon-toot--media-attachments
                 `(((:contents . ,(mastodon-http--read-file-as-string file))
                    (:description . ,description)
                    (:filename . ,file)))))
    (mastodon-toot--refresh-attachments-display)
    ;; upload only most recent attachment:
    (mastodon-toot--upload-attached-media (car (last mastodon-toot--media-attachments)))))
(defun mastodon-toot--upload-attached-media (attachment)
  "Upload a single ATTACHMENT using `mastodon-http--post-media-attachment'.
The item's id is added to `mastodon-toot--media-attachment-ids',
which is used to attach it to a toot when posting."
  (let* ((filename (expand-file-name
                    (alist-get :filename attachment)))
         (caption (alist-get :description attachment))
         (url (concat mastodon-instance-url "/api/v2/media")))
    (message "Uploading %s..." (file-name-nondirectory filename))
    (mastodon-http--post-media-attachment url filename caption)))
(defun mastodon-toot--refresh-attachments-display ()
  "Update the display attachment previews in toot draft buffer."
  (let ((inhibit-read-only t)
        (attachments-region (mastodon-tl--find-property-range
                             'toot-attachments (point-min)))
        (display-specs (mastodon-toot--format-attachments)))
    (dotimes (i (- (cdr attachments-region) (car attachments-region)))
      (add-text-properties (+ (car attachments-region) i)
                           (+ (car attachments-region) i 1)
                           (list 'display (or (nth i display-specs) ""))))))
(defun mastodon-toot--format-attachments ()
  "Format the attachment previews for display in toot draft buffer."
  (or (let ((counter 0)
            (image-options (when (or (image-type-available-p 'imagemagick)
                                     (image-transforms-p))
                             `(:height ,mastodon-toot--attachment-height))))
        (mapcan (lambda (attachment)
                  (let* ((data (alist-get :contents attachment))
                         (image (apply #'create-image data
                                       (if (version< emacs-version "27.1")
                                           (when image-options 'imagemagick)
                                         nil) ; inbuilt scaling in 27.1
                                       t image-options))
                         (description (alist-get :description attachment)))
                    (setq counter (1+ counter))
                    (list (format "\n    %d: " counter)
                          image
                          (format " \"%s\"" description))))
                mastodon-toot--media-attachments))
      (list "None")))
(defun mastodon-toot--fetch-max-poll-options (instance)
  "Return the maximum number of poll options from INSTANCE, which is json."
  (mastodon-toot--fetch-poll-field 'max_options instance))
(defun mastodon-toot--fetch-max-poll-option-chars (instance)
  "Return the maximum number of characters a poll option may have.
INSTANCE is JSON."
  (if (alist-get 'pleroma instance)
      (mastodon-toot--fetch-poll-field 'max_option_chars instance)
    (or (mastodon-toot--fetch-poll-field 'max_characters_per_option instance)
        50))) ; masto default
(defun mastodon-toot--fetch-poll-field (field instance)
  "Return FIELD from the poll settings from INSTANCE, which is json."
  (let* ((polls (if (alist-get 'pleroma instance)
                    (alist-get 'poll_limits instance)
                  (alist-get 'polls
                             (alist-get 'configuration instance)))))
    (alist-get field polls)))
(defun mastodon-toot--read-poll-options-count (max)
  "Read the user's choice of the number of options the poll should have.
MAX is the maximum number set by their instance."
  (let ((number (read-number
                 (format "Number of options [2-%s]: " max) 2)))
    (if (> number max)
        (error "You need to choose a number between 2 and %s" max)
      number)))
(defun mastodon-toot--create-poll ()
  "Prompt for new poll options and return as a list."
  (interactive)
  ;; re length, API docs show a poll 9 options.
  (let* ((instance (mastodon-http--get-json (mastodon-http--api "instance")))
         (max-options (mastodon-toot--fetch-max-poll-options instance))
         (count (mastodon-toot--read-poll-options-count max-options))
         (length (mastodon-toot--fetch-max-poll-option-chars instance))
         (multiple-p (y-or-n-p "Multiple choice? "))
         (options (mastodon-toot--read-poll-options count length))
         (hide-totals (y-or-n-p "Hide votes until poll ends? "))
         (expiry (mastodon-toot--read-poll-expiry)))
    (setq mastodon-toot-poll
          `(:options ,options :length ,length :multi ,multiple-p
                     :hide ,hide-totals :expiry ,expiry))
    (message "poll created!")))
(defun mastodon-toot--read-poll-options (count length)
  "Read a list of options for poll with COUNT options.
LENGTH is the maximum character length allowed for a poll option."
  (let* ((choices
          (cl-loop for x from 1 to count
                   collect (read-string
                            (format "Poll option [%s/%s] [max %s chars]: "
                                    x count length))))
         (longest (cl-reduce #'max (mapcar #'length choices))))
    (if (> longest length)
        (progn
          (message "looks like you went over the max length. Try again.")
          (sleep-for 2)
          (mastodon-toot--read-poll-options count length))
      choices)))
(defun mastodon-toot--read-poll-expiry ()
  "Prompt for a poll expiry time."
  ;; API requires this in seconds
  (let* ((options (mastodon-toot--poll-expiry-options-alist))
         (response (completing-read "poll ends in [or enter seconds]: "
                                    options nil 'confirm)))
    (or (alist-get response options nil nil #'equal)
        (if (< (string-to-number response) 600)
            "600" ;; min 5 mins
          response))))
(defun mastodon-toot--poll-expiry-options-alist ()
  "Return an alist of seconds options."
  `(("5 minutes" . ,(number-to-string (* 60 5)))
    ("30 minutes" . ,(number-to-string (* 60 30)))
    ("1 hour" . ,(number-to-string (* 60 60)))
    ("6 hours" . ,(number-to-string (* 60 60 6)))
    ("1 day" . ,(number-to-string (* 60 60 24)))
    ("3 days" . ,(number-to-string (* 60 60 24 3)))
    ("7 days" . ,(number-to-string (* 60 60 24 7)))
    ("14 days" . ,(number-to-string (* 60 60 24 14)))
    ("30 days" . ,(number-to-string (* 60 60 24 30)))))
(defun mastodon-toot--set-toot-language ()
  "Prompt for a language and set `mastodon-toot--language'.
Return its two letter ISO 639 1 code."
  (interactive)
  (let* ((choice (completing-read "Language for this toot: "
                                  mastodon-iso-639-1)))
    (setq mastodon-toot--language
          (alist-get choice mastodon-iso-639-1 nil nil 'equal))
    (message "Language set to %s" choice)
    (mastodon-toot--update-status-fields)))
(defun mastodon-toot--schedule-toot (&optional reschedule)
  "Read a date (+ time) in the minibuffer and schedule the current toot.
With RESCHEDULE, reschedule the scheduled toot at point without editing."
  ;; original idea by christian tietze, thanks!
  ;; https://codeberg.org/martianh/mastodon.el/issues/285
  (interactive)
  (cond ((mastodon-tl--buffer-type-eq 'edit-toot)
         (message "You can't schedule toots you're editing."))
        ((not (or (mastodon-tl--buffer-type-eq 'new-toot)
                  (mastodon-tl--buffer-type-eq 'scheduled-statuses)))
         (message "You can only schedule toots from the compose toot buffer or the scheduled toots view."))
        (t
         (let* ((id (when reschedule (mastodon-tl--property 'id :no-move)))
                (ts (when reschedule
                      (alist-get 'scheduled_at
                                 (mastodon-tl--property 'scheduled-json :no-move))))
                (time-value
                 (org-read-date t t nil "Schedule toot:"
                                ;; default to scheduled timestamp if already set:
                                (mastodon-toot--iso-to-org
                                 ;; we are rescheduling without editing:
                                 (or ts
                                     ;; we are maybe editing the scheduled toot:
                                     mastodon-toot--scheduled-for))))
                (iso8601-str (format-time-string "%FT%T%z" time-value))
                (msg-str (format-time-string "%d-%m-%y at %H:%M[%z]" time-value)))
           (if (not reschedule)
               (progn
                 (setq-local mastodon-toot--scheduled-for iso8601-str)
                 (message (format "Toot scheduled for %s." msg-str)))
             (let* ((args (when reschedule `(("scheduled_at" . ,iso8601-str))))
                    (url (when reschedule (mastodon-http--api
                                           (format "scheduled_statuses/%s" id))))
                    (response (mastodon-http--put url args)))
               (mastodon-http--triage response
                                      (lambda ()
                                        ;; reschedule means we are in scheduled toots view:
                                        (mastodon-views--view-scheduled-toots)
                                        (message
                                         (format "Toot rescheduled for %s." msg-str))))))))))
(defun mastodon-toot--iso-to-human (ts)
  "Format an ISO8601 timestamp TS to be more human-readable."
  (let* ((decoded (iso8601-parse ts))
         (encoded (encode-time decoded)))
    (format-time-string "%d-%m-%y, %H:%M[%z]" encoded)))
(defun mastodon-toot--iso-to-org (ts)
  "Convert ISO8601 timestamp TS to something `org-read-date' can handle."
  (when ts (let* ((decoded (iso8601-parse ts)))
             (encode-time decoded))))
;; we'll need to revisit this if the binds get
;; more diverse than two-chord bindings
(defun mastodon-toot--get-mode-kbinds ()
  "Get a list of the keybindings in the mastodon-toot-mode."
  (let* ((binds (copy-tree mastodon-toot-mode-map))
         (prefix (car (cadr binds)))
         (bindings (remove nil (mapcar (lambda (i) (if (listp i) i))
                                       (cadr binds)))))
    (mapcar (lambda (b)
              (setf (car b) (vector prefix (car b)))
              b)
            bindings)))
(defun mastodon-toot--format-kbind-command (cmd)
  "Format CMD to be more readable.
e.g. mastodon-toot--send -> Send."
  (let* ((str (symbol-name cmd))
         (re "--\\(.*\\)$")
         (str2 (save-match-data
                 (string-match re str)
                 (match-string 1 str))))
    (capitalize (replace-regexp-in-string "-" " " str2))))
(defun mastodon-toot--format-kbind (kbind)
  "Format a single keybinding, KBIND, for display in documentation."
  (let ((key (help-key-description (car kbind) nil))
        (command (mastodon-toot--format-kbind-command (cdr kbind))))
    (format "    %s - %s" key command)))
(defun mastodon-toot--format-kbinds (kbinds)
  "Format a list of keybindings, KBINDS, for display in documentation."
  (mapcar #'mastodon-toot--format-kbind kbinds))
(defvar-local mastodon-toot--kbinds-pairs nil
  "Contains a list of paired toot compose buffer keybindings for inserting.")
(defun mastodon-toot--formatted-kbinds-pairs (kbinds-list longest)
  "Return a list of strings each containing two formatted kbinds.
KBINDS-LIST is the list of formatted bindings to pair.
LONGEST is the length of the longest binding."
  (when kbinds-list
    (push (concat "\n"
                  (car kbinds-list)
                  (make-string (- (1+ longest) (length (car kbinds-list)))
                               ?\ )
                  (cadr kbinds-list))
          mastodon-toot--kbinds-pairs)
    (mastodon-toot--formatted-kbinds-pairs (cddr kbinds-list) longest))
  (reverse mastodon-toot--kbinds-pairs))
(defun mastodon-toot--formatted-kbinds-longest (kbinds-list)
  "Return the length of the longest item in KBINDS-LIST."
  (let ((lengths (mapcar (lambda (x)
                           (length x))
                         kbinds-list)))
    (car (sort lengths #'>))))
(defun mastodon-toot--make-mode-docs ()
  "Create formatted documentation text for the mastodon-toot-mode."
  (let* ((kbinds (mastodon-toot--get-mode-kbinds))
         (longest-kbind
          (mastodon-toot--formatted-kbinds-longest
           (mastodon-toot--format-kbinds kbinds))))
    (concat
     " Compose a new toot here. The following keybindings are available:"
     (mapconcat #'identity
                (mastodon-toot--formatted-kbinds-pairs
                 (mastodon-toot--format-kbinds kbinds)
                 longest-kbind)
                nil))))
(defun mastodon-toot--format-reply-in-compose-string (reply-text)
  "Format a REPLY-TEXT for display in compose buffer docs."
  (let* ((rendered (mastodon-tl--render-text reply-text))
         (no-props (substring-no-properties rendered))
         ;; FIXME: this regex replaces \n at end of every post
         ;; so we have to trim:
         (no-newlines (string-trim
                       (replace-regexp-in-string "[\n]+" " " no-props)))
         (reply-to (concat " Reply to: \"" no-newlines "\""))
         (crop (truncate-string-to-width
                ;; (string-limit
                reply-to
                mastodon-toot-orig-in-reply-length)))
    (if (> (length no-newlines)
           (length crop)) ; we cropped:
        (concat crop "\n")
      (concat reply-to "\n"))))
(defun mastodon-toot--display-docs-and-status-fields (&optional reply-text)
  "Insert propertized text with documentation about `mastodon-toot-mode'.
Also includes and the status fields which will get updated based
on the status of NSFW, content warning flags, media attachments, etc.
REPLY-TEXT is the text of the toot being replied to."
  (let ((divider
         "|=================================================================|"))
    (insert
     (propertize
      (concat
       (mastodon-toot--make-mode-docs) "\n"
       divider "\n"
       " "
       (propertize "Count"
                   'toot-post-counter t)
       " ⋅ "
       (propertize "Visibility"
                   'toot-post-visibility t)
       " ⋅ "
       (propertize "Language"
                   'toot-post-language t)
       " "
       (propertize "Scheduled"
                   'toot-post-scheduled t)
       " "
       (propertize "CW"
                   'toot-post-cw-flag t)
       " "
       (propertize "NSFW"
                   'toot-post-nsfw-flag t)
       "\n"
       " Attachments: "
       (propertize "None                  "
                   'toot-attachments t)
       "\n"
       (if reply-text
           (propertize
            (mastodon-toot--format-reply-in-compose-string reply-text)
            'toot-reply t)
         "")
       divider
       "\n")
      'rear-nonsticky t
      'face 'mastodon-toot-docs-face
      'read-only "Edit your message below."
      'toot-post-header t))))
(defun mastodon-toot--most-restrictive-visibility (reply-visibility)
  "Return REPLY-VISIBILITY or default visibility, whichever is more restrictive.
The default is given by `mastodon-toot--default-reply-visibility'."
  (unless (null reply-visibility)
    (let ((less-restrictive (member (intern mastodon-toot--default-reply-visibility)
				    mastodon-toot-visibility-list)))
      (if (member (intern reply-visibility) less-restrictive)
	  mastodon-toot--default-reply-visibility reply-visibility))))
(defun mastodon-toot--setup-as-reply (reply-to-user reply-to-id reply-json)
  "If REPLY-TO-USER is provided, inject their handle into the message.
If REPLY-TO-ID is provided, set `mastodon-toot--reply-to-id'.
REPLY-JSON is the full JSON of the toot being replied to."
  (let ((reply-visibility
	 (mastodon-toot--most-restrictive-visibility
	  (alist-get 'visibility reply-json)))
        (reply-cw (alist-get 'spoiler_text reply-json)))
    (when reply-to-user
      (when (> (length reply-to-user) 0) ; self is "" unforch
        (insert (format "%s " reply-to-user)))
      (setq mastodon-toot--reply-to-id reply-to-id)
      (unless (equal mastodon-toot--visibility reply-visibility)
        (setq mastodon-toot--visibility reply-visibility))
      (mastodon-toot--set-cw reply-cw))))
(defun mastodon-toot--update-status-fields (&rest _args)
  "Update the status fields in the header based on the current state."
  (ignore-errors  ;; called from after-change-functions so let's not leak errors
    (let* ((inhibit-read-only t)
           (header-region (mastodon-tl--find-property-range 'toot-post-header
                                                            (point-min)))
           (count-region (mastodon-tl--find-property-range 'toot-post-counter
                                                           (point-min)))
           (visibility-region (mastodon-tl--find-property-range
                               'toot-post-visibility (point-min)))
           (nsfw-region (mastodon-tl--find-property-range 'toot-post-nsfw-flag
                                                          (point-min)))
           (cw-region (mastodon-tl--find-property-range 'toot-post-cw-flag
                                                        (point-min)))
           (lang-region (mastodon-tl--find-property-range 'toot-post-language
                                                          (point-min)))
           (scheduled-region (mastodon-tl--find-property-range 'toot-post-scheduled
                                                               (point-min)))
           (toot-string (buffer-substring-no-properties (cdr header-region)
                                                        (point-max))))
      (add-text-properties (car count-region) (cdr count-region)
                           (list 'display
                                 (format "%s/%s chars"
                                         (mastodon-toot--count-toot-chars toot-string)
                                         (number-to-string mastodon-toot--max-toot-chars))))
      (add-text-properties (car visibility-region) (cdr visibility-region)
                           (list 'display
                                 (format "%s"
                                         (if (equal
                                              mastodon-toot--visibility
                                              "private")
                                             "followers-only"
                                           mastodon-toot--visibility))))
      (add-text-properties (car lang-region) (cdr lang-region)
                           (list 'display
                                 (if mastodon-toot--language
                                     (format "Lang: %s ⋅"
                                             mastodon-toot--language)
                                   "")))
      (add-text-properties (car scheduled-region) (cdr scheduled-region)
                           (list 'display
                                 (if mastodon-toot--scheduled-for
                                     (format "Scheduled: %s ⋅"
                                             (mastodon-toot--iso-to-human
                                              mastodon-toot--scheduled-for))
                                   "")))
      (add-text-properties (car nsfw-region) (cdr nsfw-region)
                           (list 'display (if mastodon-toot--content-nsfw
                                              (if mastodon-toot--media-attachments
                                                  "NSFW" "NSFW (for attachments only)")
                                            "")
                                 'face 'mastodon-cw-face))
      (add-text-properties (car cw-region) (cdr cw-region)
                           (list 'invisible (not mastodon-toot--content-warning)
                                 'face 'mastodon-cw-face)))))
(defun mastodon-toot--count-toot-chars (toot-string &optional cw)
  "Count the characters in TOOT-STRING.
URLs always = 23, and domain names of handles are not counted.
This is how mastodon does it.
CW is the content warning, which contributes to the character count."
  (with-temp-buffer
    (switch-to-buffer (current-buffer))
    (insert toot-string)
    (goto-char (point-min))
    ;; handle URLs
    (while (search-forward-regexp "\\w+://[^ \n]*" nil t) ; URL
      (replace-match "xxxxxxxxxxxxxxxxxxxxxxx")) ; 23 x's
    ;; handle @handles
    (goto-char (point-min))
    (while (search-forward-regexp (concat "\\(?2:@[^ @\n]+\\)" ; a handle only
                                          "\\(@[^ \n]+\\)?" ; with poss domain
                                          "\\b")
                                  nil t)
      (replace-match (match-string 2))) ; replace with handle only
    (+ (length cw)
       (length (buffer-substring (point-min) (point-max))))))
(defun mastodon-toot--save-toot-text (&rest _args)
  "Save the current toot text in `mastodon-toot-current-toot-text'.
Added to `after-change-functions' in new toot buffers."
  (let ((text (mastodon-toot--remove-docs)))
    (unless (string-empty-p text)
      (setq mastodon-toot-current-toot-text text))))
(defun mastodon-toot--open-draft-toot ()
  "Prompt for a draft and compose a toot with it."
  (interactive)
  (if mastodon-toot-draft-toots-list
      (let ((text (completing-read "Select draft toot: "
                                   mastodon-toot-draft-toots-list
                                   nil t)))
        (if (mastodon-toot--compose-buffer-p)
            (when (and (not (mastodon-toot--empty-p :text-only))
                       (y-or-n-p "Replace current text with draft?"))
              (cl-pushnew mastodon-toot-current-toot-text
                          mastodon-toot-draft-toots-list)
              (goto-char
               (cdr (mastodon-tl--find-property-range 'toot-post-header
                                                      (point-min))))
              (kill-region (point) (point-max))
              ;; to not save to kill-ring:
              ;; (delete-region (point) (point-max))
              (insert text))
          (mastodon-toot--compose-buffer nil nil nil text)))
    (unless (mastodon-toot--compose-buffer-p)
      (mastodon-toot--compose-buffer))
    (message "No drafts available.")))
(defun mastodon-toot--delete-draft-toot ()
  "Prompt for a draft toot and delete it."
  (interactive)
  (if mastodon-toot-draft-toots-list
      (let ((draft (completing-read "Select draft to delete: "
                                    mastodon-toot-draft-toots-list
                                    nil t)))
        (setq mastodon-toot-draft-toots-list
              (cl-delete draft mastodon-toot-draft-toots-list
                         :test 'equal))
        (message "Draft deleted!"))
    (message "No drafts to delete.")))
(defun mastodon-toot--delete-all-drafts ()
  "Delete all drafts."
  (interactive)
  (setq mastodon-toot-draft-toots-list nil)
  (message "All drafts deleted!"))
(defun mastodon-toot--propertize-tags-and-handles (&rest _args)
  "Propertize tags and handles in toot compose buffer.
Added to `after-change-functions'."
  (when (mastodon-toot--compose-buffer-p)
    (let ((header-region
           (mastodon-tl--find-property-range 'toot-post-header
                                             (point-min)))
          (face (when mastodon-toot--proportional-fonts-compose
                  'variable-pitch)))
      ;; cull any prev props:
      ;; stops all text after a handle or mention being propertized:
      (set-text-properties (cdr header-region) (point-max) `(face ,face))
      (mastodon-toot--propertize-item mastodon-toot-tag-regex
                                      'success
                                      (cdr header-region))
      (mastodon-toot--propertize-item mastodon-toot-handle-regex
                                      'mastodon-display-name-face
                                      (cdr header-region))
      (mastodon-toot--propertize-item mastodon-toot-url-regex
                                      'link
                                      (cdr header-region)))))
(defun mastodon-toot--propertize-item (regex face start)
  "Propertize item matching REGEX with FACE starting from START."
  (save-excursion
    (goto-char start)
    (cl-loop while (search-forward-regexp regex nil :noerror)
             do (add-text-properties (match-beginning 2)
                                     (match-end 2)
                                     `(face ,face)))))
(defun mastodon-toot--compose-buffer-p ()
  "Return t if compose buffer is current."
  (or (mastodon-tl--buffer-type-eq 'edit-toot)
      (mastodon-tl--buffer-type-eq 'new-toot)))
(defun mastodon-toot--fill-reply-in-compose ()
  "Fill reply text in compose buffer to the width of the divider."
  (save-excursion
    (save-match-data
      (let* ((fill-column 67))
        (goto-char (point-min))
        ;; while-let shoulndn't be needed here, as we really should only have
        ;; one. if we have more, the bug is elsewhere.
        (when-let ((prop (text-property-search-forward 'toot-reply)))
          (fill-region (prop-match-beginning prop)
                       (point)))))))
;; NB: now that we have toot drafts, to ensure offline composing remains
;; possible, avoid any direct requests here:
(defun mastodon-toot--compose-buffer
    (&optional reply-to-user reply-to-id reply-json initial-text edit)
  "Create a new buffer to capture text for a new toot.
If REPLY-TO-USER is provided, inject their handle into the message.
If REPLY-TO-ID is provided, set the `mastodon-toot--reply-to-id' var.
REPLY-JSON is the full JSON of the toot being replied to.
INITIAL-TEXT is used by `mastodon-toot-insert-draft-toot' to add
a draft into the buffer.
EDIT means we are editing an existing toot, not composing a new one."
  (let* ((buffer-name (if edit "*edit toot*" "*new toot*"))
         (buffer-exists (get-buffer buffer-name))
         (buffer (or buffer-exists (get-buffer-create buffer-name)))
         (inhibit-read-only t)
         (reply-text (alist-get 'content
                                (or (alist-get 'reblog reply-json)
                                    reply-json)))
         (previous-window-config (list (current-window-configuration)
                                       (point-marker))))
    (switch-to-buffer-other-window buffer)
    (text-mode)
    (mastodon-toot-mode t)
    (setq mastodon-toot--visibility
          (or (plist-get mastodon-profile-account-settings 'privacy)
              ;; use toot visibility setting from the server:
              (mastodon-profile--get-source-pref 'privacy)
              "public")) ; fallback
    (unless buffer-exists
      (if mastodon-toot-display-orig-in-reply-buffer
          (progn
            (mastodon-toot--display-docs-and-status-fields reply-text)
            (mastodon-toot--fill-reply-in-compose))
        (mastodon-toot--display-docs-and-status-fields))
      ;; `reply-to-user' (alone) is also used by `mastodon-tl--dm-user', so
      ;; perhaps we should not always call --setup-as-reply, or make its
      ;; workings conditional on reply-to-id. currently it only checks for
      ;; reply-to-user.
      (mastodon-toot--setup-as-reply reply-to-user reply-to-id reply-json))
    (unless mastodon-toot--max-toot-chars
      ;; no need to fetch from `mastodon-profile-account-settings' as
      ;; `mastodon-toot--max-toot-chars' is set when we set it
      (mastodon-toot--get-max-toot-chars))
    ;; set up completion:
    (when mastodon-toot--enable-completion
      (set ; (setq-local
       (make-local-variable 'completion-at-point-functions)
       (add-to-list 'completion-at-point-functions
                    #'mastodon-toot--mentions-capf))
      (add-to-list 'completion-at-point-functions
                   #'mastodon-toot--tags-capf)
      ;; company
      (when (and mastodon-toot--use-company-for-completion
                 (require 'company nil :no-error))
        (declare-function company-mode-on "company")
        (set (make-local-variable 'company-backends)
             (add-to-list 'company-backends 'company-capf))
        (company-mode-on)))
    ;; after-change:
    (make-local-variable 'after-change-functions)
    (cl-pushnew #'mastodon-toot--update-status-fields after-change-functions)
    (cl-pushnew #'mastodon-toot--save-toot-text after-change-functions)
    (cl-pushnew #'mastodon-toot--propertize-tags-and-handles after-change-functions)
    (mastodon-toot--update-status-fields)
    (mastodon-toot--propertize-tags-and-handles)
    (mastodon-toot--refresh-attachments-display)
    ;; draft toot text saving:
    (setq mastodon-toot-current-toot-text nil)
    ;; if we set this before changing modes, it gets nuked:
    (setq mastodon-toot-previous-window-config previous-window-config)
    (when mastodon-toot--proportional-fonts-compose
      (facemenu-set-face 'variable-pitch))
    (when initial-text
      (insert initial-text))))
;; flyspell ignore masto toot regexes:
(defvar flyspell-generic-check-word-predicate)
(defun mastodon-toot-mode-flyspell-verify ()
  "A predicate function for `flyspell'.
Only text that is not one of these faces will be spell-checked."
  (let ((faces '(mastodon-display-name-face
                 mastodon-toot-docs-face font-lock-comment-face
                 success link)))
    (unless (eql (point) (point-min))
      ;; (point) is next char after the word. Must check one char before.
      (let ((f (get-text-property (1- (point)) 'face)))
        (not (memq f faces))))))
(add-hook 'mastodon-toot-mode-hook
    	  (lambda ()
            (setq flyspell-generic-check-word-predicate
                  'mastodon-toot-mode-flyspell-verify)))
;;;###autoload
(add-hook 'mastodon-toot-mode-hook
          #'mastodon-profile--fetch-server-account-settings-maybe)
;; disable auto-fill-mode:
(add-hook 'mastodon-toot-mode-hook
          (lambda ()
            (auto-fill-mode -1)))
(define-minor-mode mastodon-toot-mode
  "Minor mode to capture Mastodon toots."
  :keymap mastodon-toot-mode-map
  :global nil)
(provide 'mastodon-toot)
;;; mastodon-toot.el ends here