diff --git a/.github/workflows/publish-docker-image.yml b/.github/workflows/publish-docker-image.yml
index ff60fb7a9e..47363641bc 100644
--- a/.github/workflows/publish-docker-image.yml
+++ b/.github/workflows/publish-docker-image.yml
@@ -4,6 +4,7 @@ on:
     branches:
       - master
       - dev
+      - multiuser
     tags:
       - '**'
 jobs:
diff --git a/.gitignore b/.gitignore
index a9606b5a04..c56c8edb3b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -163,7 +163,7 @@ celerybeat.pid
 .env
 .venv
 env/
-venv/
+venv*/
 ENV/
 env.bak/
 venv.bak/
@@ -299,5 +299,8 @@ icon/
 *.sh
 *.bat
 *.cmd
+*.bak
 docker-compose*.yml
-.version
\ No newline at end of file
+.version
+src/db/config_**_sample.py
+src/db/create_migrations.py
diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index 08bc846242..0000000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,173 +0,0 @@
-# Changelog
-
-## v1.6.1
-
-### en
-
-**This is a rushed release. It bumps the dependency `telethon` to the latest version. Please upgrade to this version
-immediately to avoid being unable to login due to the outdated dependency.**
-
-The bot is currently being actively developed on the `multiuser` branch, but has not been merged back yet to avoid
-introducing breaking changes too early. If you would like to try the multi-user version, there is a public
-demo [@RSStT_Bot](https://t.me/RSStT_Bot) .
-
-#### New features
-
-- `.env` file support (only for manual execution, not for docker)
-- Unescape HTML-escaped post title
-- Use the title as the content of a post if the latter is of no text
-
-#### Changes
-
-- Minor bugfixes
-- Introduce some workarounds to avoid being flood-controlled frequently
-- Introduce some deps to speedup HTTP requests
-
-### zh-Hans
-
-**这是一个仓促的发布。它将依赖 `telethon` 升级到了最新版本。请立即升级到这个版本以免由于依赖过时而无法登录。**
-
-机器人正在 `multiuser` 分支上被活跃开发，但尚未被合并回来，以免过早引入重大变更。如果你想要尝试多用户版本，这里有一个公开的 demo [@RSStT_Bot](https://t.me/RSStT_Bot) 。
-
-#### 新特性
-
-- `.env` 文件支持 (仅在手动执行时支持，不支持 docker)
-- 反转义受到 HTML 转义的文章标题
-- 当文章内容不含有文本时，将标题作为文章的内容
-
-#### 变更
-
-- 一些小的错误修复
-- 引入了一些变通解决方案以免频繁受到泛洪控制
-- 引入了一些依赖以加速 HTTP 请求
-
-## v1.6.0
-
-### en
-
-#### BREAKING CHANGE
-
-- Telegram bot library has been migrated from `python-telegram-bot` (which uses HTTP Bot API and is synchronous)
-  to `telethon` (which uses MTProto Bot API and is asynchronous)
-    - However, to use MTProto Bot API, an API key is needed. The bot has 7 built-in API keys (collected from the
-      Internet) and in most cases it should not be unable to log in. But if so, please obtain your own API key (
-      see [docker-compose.yml.sample](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/blob/53f11a473933e620d707c9d15f6d48737bd7a982/docker-compose.yml.sample#L43)
-      for details)
-
-#### New features
-
-- Thanks to the migration of Telegram bot library, bot can now connect to its DC directly, need not detour through the
-  HTTP Bot API and keep polling to get new messages. Which makes the bot receive and reply messages more rapidly and
-  lightweightedly. Even if the HTTP Bot API is down, the bot can still run unaffectedly. (more
-  details: [Advantages of MTProto over Bot API](https://docs.telethon.dev/en/latest/concepts/botapi-vs-mtproto.html#advantages-of-mtproto-over-bot-api)
-  , [MTProto vs HTTP Bot API](https://github.com/LonamiWebs/Telethon/wiki/MTProto-vs-HTTP-Bot-API))
-- Support parsing more HTML elements
-    - `<iframe>`
-    - `<video><source><source>...</video>`
-    - `<code>`
-    - `<pre>`
-- Support OPML importing and exporting
-- Support sending too-long post via Telegraph (env var `TELEGRAPH_TOKEN` must be set)
-- Support redis as db
-    - Note: This is a workaround for deploying the bot on [railway.app](), will be dropped in the future
-- Support arm64 (docker build)
-- Support resending a message using a media relay server if Telegram cannot send a message with media due to Telegram
-  server instability or network instability between media server and Telegram server
-- Support colored logging
-- `docker-compose.yml.sample`
-- `/version` command to check bot version
-- Automatically use proxy if global proxy (env var `SOCKS_PROXY`/`HTTP_PROXY`) set
-
-#### Changes
-
-- Assign feed monitoring tasks to every minute, instead of executing all at once each `DELAY`
-    - Thus, env var `DELAY` can only be 60~3600
-    - Note: env var `DELAY` will be deprecated in the future
-- Recognize a post by its `guid`/`id` instead of `link`
-- Simplify the output of `/list`
-- Bump Python to 3.9 (docker build)
-- Minor fixes
-
-### zh-Hans
-
-#### 重大变更
-
-- 与 Telegram 交互的库由使用 HTTP Bot API 的同步库 `python-telegram-bot` 改为使用 MTProto Bot API 的异步库 `telethon`
-    - 这引入了 API key 的需求，程序已经内置了 7 个公开的 API key，通常情况下不应无法登入。如果无法登入，可以自己申请 API key (
-      详见 [docker-compose.yml.sample](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/blob/53f11a473933e620d707c9d15f6d48737bd7a982/docker-compose.yml.sample#L43)
-      中的说明)
-
-#### 新特性
-
-- 由于 Telegram bot 库的替换，bot 可以直接连接到 bot 所属的 DC，不需绕经 HTTP Bot API；也不需轮询获得消息更新，它在接收及发送消息方面都更为迅速，资源占用也更低； 即使 HTTP Bot API
-  宕机，bot 也可以正常工作 (
-  详见 [Advantages of MTProto over Bot API](https://docs.telethon.dev/en/latest/concepts/botapi-vs-mtproto.html#advantages-of-mtproto-over-bot-api)
-  和 [MTProto vs HTTP Bot API](https://github.com/LonamiWebs/Telethon/wiki/MTProto-vs-HTTP-Bot-API))
-- 支持更多元素的解析
-    - `<iframe>`
-    - `<video><source><source>...</video>`
-    - `<code>`
-    - `<pre>`
-- 支持 OPML 导入导出
-- 支持超长文章通过 Telegraph 发送 (必须先设置 `TELEGRAPH_TOKEN` 环境变量)
-- 支持使用 redis 作为数据库
-    - 注意：这是为了在 [railway.app]() 上部署而设计的变通解决方案，未来很可能丢弃
-- 支持 arm64 (docker 构建)
-- 支持在由于 Telegram 服务器不稳定或 Telegram 服务器与媒体服务器之间的网络连接不稳定而导致 Telegram 无法发出带有媒体的消息时，使用媒体反代服务器重新发送。
-- 支持日志着色
-- `docker-compose.yml.sample`
-- 用于检查 bot 版本的 `/version` 命令
-- 如果设置了全局代理 (环境变量 `SOCKS_PROXY`/`HTTP_PROXY`)，会使用它们
-
-#### 变更
-
-- 将 feed 监视任务分配到每分钟，而不是每次 `DELAY` 一次性全部执行
-    - 因此，环境变量 `DELAY` 将只能被设置为 60~3600
-    - 注意：环境变量 `DELAY` 未来将被弃用
-- 使用 `guid`/`id` 来辨识一个 post，而不是 `link`
-- 简化了 `/list` 的输出
-- 升级为 Python 3.9 (docker 构建)
-- 次要的修复
-
-## v1.5.0
-
-### en
-
-- Post parser is completely rewritten, more stable and can keep text formatting as much as possible
-- GIF Support
-- When the message is more than 10 pieces of media, send it in pieces
-- Support video and pictures to be mixed in the same message arbitrarily
-- Invalid media are no longer directly discarded, but attached to the end of the message as a link
-- Automatically determine whether the title of the RSS feed is auto-filled, if so, omit the title
-- Automatically show the author name
-- Automatically replace emoji shortcodes with emoji
-- Automatically replace emoji images with emoji or its description text
-- When an image cannot be sent due to the instability of telegram api, the image server will be automatically replaced
-  and resent
-    - Only for Weibo images, non-Weibo images will be attached to the end of the message as a link
-- Improve the text length counting method, no longer cause the message to be divided wrongly due to a long link URL
-- Change the user-agent, because some websites have banned the UA of Requests
-- Logging improvement
-
-### zh-Hans
-
-- **文章解码完全重写，更加稳定及更加忠实还原原有格式**
-    - **针对大量短动态类 RSS 源进行了测试**
-    - **即使是长文 RSS 源，也可以正确处理**
-- **支持 GIF**
-- **消息多于 10 张媒体时支持分条发送**
-- **支持视频与图片任意混合于同一条消息**
-- 超限媒体不再直接丢弃，而是作为链接附加到消息末尾
-- 自动判断 RSS 源的标题是否为自动填充，并自动选择是否略去标题
-- 自动显示作者名
-- 自动替换 emoji shortcodes 为 emoji
-- 自动替换满足某些特征的表情图片为 emoji 或其描述文本
-- 因 telegram api 不稳定而无法发出图片时，自动更换图床服务器重发
-    - 仅限微博图源，非微博图源自动将所有媒体转为链接附加到消息末尾
-- 改进文本长度计数方式，不再因为链接 url 过长而导致消息被提前分割
-- 更改 user-agent，规避某些网站屏蔽 requests UA 的问题
-- 改进的日志记录
-
-## v1.0.0
-
-initial public release
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index 07082b48fe..0288fadd93 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-FROM python:3.9-slim AS builder
+FROM python:3.10-slim AS builder
 
 WORKDIR /app
 
@@ -22,14 +22,14 @@ COPY . /app
 RUN \
     echo "$(git describe --tags --always)@$(git branch --show-current)" | tee .version ; \
     if test $(expr length "$(cat .version)") -le 3; then echo "dirty-build@$(date -Iseconds)" | tee .version; else echo "build@$(date -Iseconds)" | tee -a .version; fi ; \
-    rm -rf .git .github resources config && \
+    rm -rf .git .github config docs && \
     mkdir -p config && \
     ls -la ; \
     cat .version
 
 #----------------------------------------
 
-FROM python:3.9-slim
+FROM python:3.10-slim
 
 WORKDIR /app
 
diff --git a/README.md b/README.md
index 6c3f91035d..248116d32f 100644
--- a/README.md
+++ b/README.md
@@ -1,103 +1,59 @@
-# RSS to Telegram Bot
+# [RSS to Telegram Bot](https://t.me/RSStT_Bot)
 
-**关心你的阅读体验的 Telegram RSS 机器人**
+**A Telegram RSS bot that cares about your reading experience**
 
-[![Build Status](https://img.shields.io/github/workflow/status/Rongronggg9/RSS-to-Telegram-Bot/Publish%20Docker%20image)](https://hub.docker.com/r/rongronggg9/rss-to-telegram)
+[简体中文 README](README.zh.md)
+
+[![Translating Status](https://hosted.weblate.org/widgets/rss-to-telegram-bot/-/glossary/svg-badge.svg)](https://hosted.weblate.org/engage/rss-to-telegram-bot/)
+[![Build Status (master)](https://img.shields.io/github/workflow/status/Rongronggg9/RSS-to-Telegram-Bot/Publish%20Docker%20image/master?label=build%20%28master%29)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/actions/workflows/publish-docker-image.yml?query=branch%3Amaster)
+[![Build Status (dev)](https://img.shields.io/github/workflow/status/Rongronggg9/RSS-to-Telegram-Bot/Publish%20Docker%20image/dev?label=build%20%28dev%29)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/actions/workflows/publish-docker-image.yml?query=branch%3Adev)
 [![Docker Pulls](https://img.shields.io/docker/pulls/rongronggg9/rss-to-telegram)](https://hub.docker.com/r/rongronggg9/rss-to-telegram)
-[![GitHub stars](https://img.shields.io/github/stars/Rongronggg9/Rss-to-Telegram-Bot?style=social)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/stargazers)
-
-[@RSStT_Bot](https://t.me/RSStT_Bot) (w/ English l10n)
-
-<a href="https://t.me/RSStT_Bot"><img src="https://rongronggg9.github.io/external-resources/RSS-to-Telegram-Bot/RSStT_icon.svg" width = "256" height = "256"  alt="RSStT_icon"/><a/>
-
-[更新日志 CHANGELOG](CHANGELOG.md)
-
-使用公共 demo [@RSStT_Bot](https://t.me/RSStT_Bot) 以体验本机器人；加入频道 [@RSStT_Channel](https://t.me/RSStT_Channel)
-以获取更新资讯；加入群组 [@RSStT_Group](https://t.me/RSStT_Group) 以参与讨论或反馈问题。
-
-[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/new/template?template=https%3A%2F%2Fgithub.com%2FRongronggg9%2FRSS-to-Telegram-Bot%2Ftree%2Fdev&plugins=redis&envs=TOKEN%2CCHATID%2CMANAGER%2CDELAY&optionalEnvs=DELAY&TOKENDesc=%E4%BD%A0%E5%9C%A8+%40BotFather+%E7%94%B3%E8%AF%B7%E5%88%B0%E7%9A%84+bot+%E7%9A%84+token&CHATIDDesc=%E4%BD%A0%E7%9A%84+userid%EF%BC%88%E7%BA%AF%E6%95%B0%E5%AD%97%EF%BC%8C%E4%BB%8E+%40userinfobot%EF%BC%89%E8%8E%B7%E5%8F%96%EF%BC%9B%E6%88%96%E8%80%85%E9%9C%80%E8%A6%81%E6%8E%A8%E9%80%81%E5%88%B0%E7%9A%84%E9%A2%91%E9%81%93%E7%94%A8%E6%88%B7%E5%90%8D%EF%BC%88%E6%A0%BC%E5%BC%8F%EF%BC%9A%40channel%EF%BC%89&MANAGERDesc=%E4%BD%A0%E7%9A%84+userid&DELAYDesc=%E9%97%B4%E9%9A%94%E5%A4%9A%E4%B9%85%E6%A3%80%E6%9F%A5%E4%B8%80%E6%AC%A1%E8%AE%A2%E9%98%85%E6%9B%B4%E6%96%B0%EF%BC%88%E5%8D%95%E4%BD%8D%EF%BC%9A%E7%A7%92%EF%BC%89&referralCode=PEOFMi)
-
-[Railway 部署教程](https://telegra.ph/%E9%80%9A%E8%BF%87-Railway-%E9%83%A8%E7%BD%B2-RSS-to-Telegram-Bot-09-13)
-
-## 功能
-
-- 将 RSS 全文发送到 Telegram
-    - 还原原有格式
-    - 自动判断 RSS 源的标题是否为自动填充，并自动选择是否略去标题
-    - 自动显示作者名
-    - 将微博表情或 emoji shortcodes 转化为 emoji
-        - 仅限有同义 emoji 的微博表情
-    - 超长消息自动分割
-        - 如果配置了 Telegraph，则会自动通过 Telegraph 发送
-    - 支持对 Telegram Bot API 和 RSS 订阅分别配置代理
-- 支持含媒体消息转发
-    - 至多 10 个媒体，可以是图片或视频
-    - 自动缩小大于 5MB 或尺寸过大 (宽度 + 高度 <= 10000) 的图片
-        - 仅限微博图源，其他图源的图片将被转为链接附加至消息末尾
-- 支持 OPML 导入导出
-- 转发失败时向 `MANAGER` 发送含错误信息的提示 **(未设定则直接发送至 `CHATID` )**
-- **设定 `MANAGER` 时只会响应对应用户的命令 (未设定则只响应 `CHATID` 对应用户的命令)**
-
-<img src="https://rongronggg9.github.io/external-resources/RSS-to-Telegram-Bot/example1.png" width = "500" alt="example1"/>
-<img src="https://rongronggg9.github.io/external-resources/RSS-to-Telegram-Bot/example3.png" width = "500" alt="example3"/>
-
-## 已知的问题
-
-- 用于频道时，无法接受频道内的命令，需直接对 bot 在私人对话中发送命令
-    - **必须设定 `MANAGER` 并使用其对应的用户操作，否则不会响应**
-- 没有多用户功能，仅可向一个用户/频道 ( `CHATID` ) 推送 RSS
-
-## 使用
-
-> [RSS to Telegram bot，专为短动态类消息设计的 RSS Bot。](https://github.com/Rongronggg9/RSS-to-Telegram-Bot)
->
-> 成功添加一个 RSS 源后, 机器人就会开始检查订阅，每 300 秒一次。 (可修改)
->
-> 标题为只是为管理 RSS 源而设的，可随意选取，但不可有空格。
->
-> 命令:  
-> **<u>/add</u>** **<u>标题</u>** **<u>RSS</u>** : 添加订阅  
-> **<u>/remove</u>** **<u>标题</u>** : 移除订阅  
-> **<u>/list</u>** : 列出数据库中的所有订阅  
-> **<u>/test</u>** **<u>RSS</u>** **<u>编号起点(可选)</u>** **<u>编号终点(可选)</u>** : 从 RSS 源处获取一条 post (编号为 0-based, 不填或超出范围默认为 0，不填编号终点默认只获取一条 post)，或者直接用 all 获取全部  
-> **<u>/import</u>** : 导入订阅  
-> **<u>/export</u>** : 导出订阅  
-> **<u>/version</u>** : 查看版本  
-> **<u>/help</u>** : 发送这条消息
->
-> 您的 chatid 是: 0123456789
-
-### 准备
-
-1. 前往 [@BotFather](https://t.me/BotFather) 创建一个 bot ，并记录下 token ，稍后填入 `TOKEN`
-2. 获得您的 userid (可使用 [@userinfobot](https://t.me/userinfobot) 获取) 并记录下来，稍后填入 `CHATID`
-    - 您也可使用一个频道来接收推送，此时 `CHATID` 格式为 `@channelusername` (不要忘记将 bot 添加到频道里!)
-3. 获得管理员 (通常为您) 的 userid ，方法同上，稍后填入 `MANAGER`
-
-### Docker Compose
-
-For the docker images go to: https://hub.docker.com/r/rongronggg9/rss-to-telegram
-
-```sh
-mkdir rsstt
-cd rsstt
-wget https://raw.githubusercontent.com/Rongronggg9/RSS-to-Telegram-Bot/master/docker-compose.yml.sample -O docker-compose.yml
-vi docker-compose.yml  # 自行按文件中的注释修改 docker-compose.yml
-docker-compose up -d
-```
-
-### Manual Execution
-
-Python 3.8+
-
-```sh
-git clone https://github.com/Rongronggg9/RSS-to-Telegram-Bot.git
-cd RSS-to-Telegram-Bot
-pip3 install -r requirements.txt
-vi .env # 参照 docker-compose.yml 设置环境变量
-python3 -u telegramRSSbot.py
-```
-
-## 备注
-
-本项目原是 [BoKKeR/RSS-to-Telegram-Bot](https://github.com/BoKKeR/RSS-to-Telegram-Bot) 的 fork ，目前除了数据库和命令名已经没有任何相像的地方了。
\ No newline at end of file
+[![GitHub Stars](https://img.shields.io/github/stars/Rongronggg9/Rss-to-Telegram-Bot?style=social)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/stargazers)
+
+<a href="https://t.me/RSStT_Bot"><img src="docs/resources/RSStT_icon.svg" width = "256" height = "256" alt="RSStT_icon"/><a/>
+
+Public bot [@RSStT_Bot](https://t.me/RSStT_Bot) | Telegram channel [@RSStT_Channel](https://t.me/RSStT_Channel) | Discussion group [@RSStT_Group](https://t.me/RSStT_Group)
+
+[CHANGELOG](docs/CHANGELOG.md) | [Documentation](docs/README.md)
+
+[![Deploy on Railway](https://railway.app/button.svg)](docs/deployment-guide.md#option-2-railwayapp)
+
+**Important**: If you have your own RSStT bot (v1), please read the [migration guide](docs/migration-guide-v2.md) to learn how to migrate to v2.
+
+## Highlights
+
+- Multi-user
+- I18n
+    - English, Simplified Chinese, Cantonese, and [more](docs/translation-guide.md)!
+- The content of the posts of an RSS feed will be sent to Telegram
+    - Keep rich-text format
+    - Keep media
+    - Automatically determine whether the title of the RSS feed is auto-filled, if so, omit the title
+    - Automatically show the author-name
+    - Automatically replace emoji shortcodes with emoji
+    - Automatically replace emoji images with emoji or its description text
+    - Automatically split too-long messages
+        - If configured Telegraph, the message will be sent via Telegraph
+- Individual proxy settings for Telegram and RSS feeds
+- OPML importing and exporting
+- Subscription customization
+- Optimized performance (see also the [FAQ](docs/FAQ.md#q-how-is-the-performance-of-the-bot-it-appears-to-have-a-slight-memory-leak-problem))
+- User-friendly
+- HTTP Caching
+
+<img src="docs/resources/example1.png" width = "300" alt=""/><img src="docs/resources/example3.png" width = "300" alt=""/><img src="docs/resources/example4.png" width = "300" alt=""/>
+
+## Deployment
+
+Read the deployment guide [here](docs/deployment-guide.md).
+
+## FAQ
+
+Read the FAQ [here](docs/FAQ.md).
+
+## Translation
+
+Read the translation guide [here](docs/translation-guide.md).  
+You can help to translate the bot using [weblate](https://hosted.weblate.org/projects/rss-to-telegram-bot/).
+
+<a href="https://hosted.weblate.org/engage/rss-to-telegram-bot/"><img src="https://hosted.weblate.org/widgets/rss-to-telegram-bot/-/glossary/open-graph.png" width = "500" alt="" /></a>
diff --git a/README.zh.md b/README.zh.md
new file mode 100644
index 0000000000..7e6702e6ec
--- /dev/null
+++ b/README.zh.md
@@ -0,0 +1,59 @@
+# [RSS to Telegram Bot](https://t.me/RSStT_Bot)
+
+**关心你的阅读体验的 Telegram RSS 机器人**
+
+[English README](README.md)
+
+[![Translating Status](https://hosted.weblate.org/widgets/rss-to-telegram-bot/-/glossary/svg-badge.svg)](https://hosted.weblate.org/engage/rss-to-telegram-bot/)
+[![Build Status (master)](https://img.shields.io/github/workflow/status/Rongronggg9/RSS-to-Telegram-Bot/Publish%20Docker%20image/master?label=build%20%28master%29)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/actions/workflows/publish-docker-image.yml?query=branch%3Amaster)
+[![Build Status (dev)](https://img.shields.io/github/workflow/status/Rongronggg9/RSS-to-Telegram-Bot/Publish%20Docker%20image/dev?label=build%20%28dev%29)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/actions/workflows/publish-docker-image.yml?query=branch%3Adev)
+[![Docker Pulls](https://img.shields.io/docker/pulls/rongronggg9/rss-to-telegram)](https://hub.docker.com/r/rongronggg9/rss-to-telegram)
+[![GitHub Stars](https://img.shields.io/github/stars/Rongronggg9/Rss-to-Telegram-Bot?style=social)](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/stargazers)
+
+<a href="https://t.me/RSStT_Bot"><img src="docs/resources/RSStT_icon.svg" width = "256" height = "256" alt="RSStT_icon"/><a/>
+
+公共 bot [@RSStT_Bot](https://t.me/RSStT_Bot) | Telegram 频道 [@RSStT_Channel](https://t.me/RSStT_Channel) | 讨论群组 [@RSStT_Group](https://t.me/RSStT_Group)
+
+[更新日志](docs/CHANGELOG.zh.md) | [文档](docs/README.md)
+
+[![Deploy on Railway](https://railway.app/button.svg)](docs/deployment-guide.md#option-2-railwayapp)
+
+**重要**: 如果你有自己的 RSStT bot (v1)，请阅读[迁移指南](docs/migration-guide-v2.zh.md) 来了解如何迁移到 v2。
+
+## 亮点
+
+- 多用户
+- 国际化
+    - 英语，简体中文，粤语，还有[更多](docs/translation-guide.md)！
+- RSS 源的文章内容可被发送至 Telegram
+    - 保持富文本格式
+    - 保持媒体文件
+    - 自动判断 RSS 源的标题是否为自动填充，并自动选择是否略去标题
+    - 自动显示作者名
+    - 自动替换 emoji shortcodes 为 emoji
+    - 自动替换满足某些特征的表情图片为 emoji 或其描述文本
+    - 自动切分超长消息
+        - 如果配置了 Telegraph，消息会通过 Telegraph 发出
+- 为 Telegram 和 RSS 源配置独立的代理设置
+- OPML 导入和导出
+- 自定义订阅
+- 优化的性能 (参见 [FAQ](docs/FAQ.zh.md#q-bot-的性能怎么样它看起来有轻微的内存泄漏问题))
+- 用户友好
+- HTTP 缓存
+
+<img src="docs/resources/example1.png" width = "300" alt=""/><img src="docs/resources/example3.png" width = "300" alt=""/><img src="docs/resources/example4.png" width = "300" alt=""/>
+
+## 部署
+
+在[这里](docs/deployment-guide.md)阅读部署指南。
+
+## FAQ
+
+在[这里](docs/FAQ.zh.md)阅读 FAQ。
+
+## 翻译
+
+在[这里](docs/translation-guide.md)阅读翻译指南。  
+你可以通过[weblate](https://hosted.weblate.org/projects/rss-to-telegram-bot/)帮助翻译这个 bot。
+
+<a href="https://hosted.weblate.org/engage/rss-to-telegram-bot/"><img src="https://hosted.weblate.org/widgets/rss-to-telegram-bot/-/glossary/open-graph.png" width = "500" alt="" /></a>
diff --git a/docker-compose.yml.sample b/docker-compose.yml.sample
index 45fa03fd6e..1f4c2b0430 100644
--- a/docker-compose.yml.sample
+++ b/docker-compose.yml.sample
@@ -1,62 +1,42 @@
-# 请先确保依赖 Docker 和 Docker Compose 均已安装
-# 将本文件放到一个你喜欢的目录里，进入这个目录
-# 如果本文件的文件名不是 docker-compose.yml, 请复制一份并改名后再修改配置并启动
-# 以后如果需要更新/停止/重启等，都在这个目录里操作
-# <------ 命令 ------>
-# 启动: docker-compose up -d
-# 结束：docker-compose down -v
-# 修改配置后更新配置: 先结束再启动
-# 更新到最新版本: 先结束, 再 docker-compose pull，再启动
-# 查看日志：docker logs rsstt
-
+# Please read https://github.com/Rongronggg9/RSS-to-Telegram-Bot/blob/master/docs/deployment-guide.md for more details.
 version: '3.6'
 
 services:
   main:
-    image: rongronggg9/rss-to-telegram  # 若要切换到 dev 分支，请替换为：rongronggg9/rss-to-telegram:dev
-    container_name: rsstt  # 如果您需要启动多个实例，请复制此文件到另外的文件夹，并修改此名字为唯一的名字
+    image: rongronggg9/rss-to-telegram  # switch to dev branch: rongronggg9/rss-to-telegram:dev
+    container_name: rsstt  # need to be unique
     restart: unless-stopped
     volumes:
       - ./config:/app/config
     environment:
-      - TOKEN=1234567890:A1BCd2EF3gH45IJK6lMN7oPqr8ST9UvWX0Yz0  # 替换为你在 @BotFather 申请到的 token
-      - CHATID=1234567890  # 替换为你在 @userinfobot 获取到的 user id，或需要推送订阅的频道的用户名（带 @）
-      - MANAGER=1234567890  # 替换为你的 user id
-      - DELAY=300  # 订阅更新检查间隔（单位：秒）
+      - TOKEN='1234567890:A1BCd2EF3gH45IJK6lMN7oPqr8ST9UvWX0Yz0'  # get it from @BotFather
+      - MANAGER=1234567890  # get it from @userinfobot
 
-# ↓------ 要停用长文自动转 telegraph，就将此区域完全注释（在每一行最前面加 # 号） ------↓ #
-# 在这里申请 access_token: https://api.telegra.ph/createaccount?short_name=rsstt&author_name=generated%20by%20rsstt&author_url=https%3a%2f%2fgithub.com%2frongronggg9%2frss-to-telegram-bot
-# 每行一个，保证缩进对齐，会轮流使用（刷新上述页面就可以取得新的 token）
-# 尽可能保证数量不少于 5 个，否则容易触发 flood control
-# 程序会在每次启动时检查 token 合法性，遇到非法 token 就会自动重新注册 telegraph 账户代替
-# 因此，不替换为自己的 token 也可以运行，但是，这么做的话，程序启动就会较慢
-#                            ↓ 替换为你自己申请到的 access_token ↓
+# ↓------ To disable sending via Telegraph, comment out this area ------↓ #
+# Get Telegraph API access tokens: https://api.telegra.ph/createAccount?short_name=RSStT&author_name=Generated%20by%20RSStT&author_url=https%3A%2F%2Fgithub.com%2FRongronggg9%2FRSS-to-Telegram-Bot
+# Refresh the page every time you get a new token.
+# If you have a lot of subscriptions, make sure to get at least 5 tokens.
+#                            ↓ Replace with your access tokens ↓
       - TELEGRAPH_TOKEN=
         1a23b456c78de90f1a23b456c78de90f1a23b456c78de90f1a23b456c78d
         1a23b456c78de90f1a23b456c78de90f1a23b456c78de90f1a23b456c78d
         1a23b456c78de90f1a23b456c78de90f1a23b456c78de90f1a23b456c78d
         1a23b456c78de90f1a23b456c78de90f1a23b456c78de90f1a23b456c78d
         1a23b456c78de90f1a23b456c78de90f1a23b456c78de90f1a23b456c78d
-# ↑------ 要停用长文自动转 telegraph，就将此区域完全注释（在每一行最前面加 # 号） ------↑ #
-
-# ↓------ 以下为可选参数，取消注释（删除 # 号）并对应修改来启用它们 ------↓ #
-      #- API_ID=1025907  # 若要使用自己的 API key，在 https://core.telegram.org/api/obtaining_api_id 创建，并替换前面的值
-      #- API_HASH=452b0359b988148995f22ff0f4229750  # 同上
-      #- IMG_RELAY_SERVER=https://rsstt-img-relay.rongrong.workers.dev/  # 自定义 Telegram 获取图片错误的时候换用的反代服务器，参见 https://github.com/rongronggg9/rsstt-img-relay
-      #- USER_AGENT=RSStT  # 自定义网络请求使用的 User-Agent
-      #- T_PROXY=socks5h://host.docker.internal:1080  # 连接 Telegram API 使用的代理，用 host.docker.internal 代替 localhost
-      #- R_PROXY=socks5h://host.docker.internal:1080  # 获取 RSS 订阅使用的代理， 用 host.docker.internal 代替 localhost
-      #- DEBUG=1  # 若要开启 debug 日志输出，请取消注释该行
-# ↑------ 以上为可选参数，取消注释（删除 # 号）并对应修改来启用它们 ------↑ #
+# ↑------ To disable sending via Telegraph, comment out this area ------↑ #
 
-# ↓------ 若不使用 sqlite 而使用 redis，请将此行以下全部取消注释，注意数据不会被自动迁移 ------↓ #
-#      - REDISHOST=redis
-#    depends_on:
-#      - redis
-#  redis:
-#    image: redis:alpine
-#    container_name: rsstt_redis  # 如果您需要启动多个实例，请复制此文件到另外的文件夹，并修改此名字为唯一的名字
-#    restart: unless-stopped
-#    command: redis-server --appendonly yes --appendfilename "redis_db.aof" --appendfsync everysec --no-appendfsync-on-rewrite no --auto-aof-rewrite-percentage 100 --auto-aof-rewrite-min-size 64mb --aof-load-truncated yes
-#    volumes:
-#      - ./config:/data
\ No newline at end of file
+# ↓------ Advanced settings ------↓ #
+# Please read https://github.com/Rongronggg9/RSS-to-Telegram-Bot/blob/master/docs/advanced-settings.md for more details.
+      #- MULTIUSER=0  # default: 1
+      #- DATABASE_URL='postgres://username:password@host:port/db_name'  # default: sqlite://config/db.sqlite3?journal_mode=OFF
+      #- API_ID=1025907  # get it from https://core.telegram.org/api/obtaining_api_id
+      #- API_HASH=452b0359b988148995f22ff0f4229750  # get it from https://core.telegram.org/api/obtaining_api_id
+      #- IMG_RELAY_SERVER='https://images.weserv.nl/?url='  # default: https://rsstt-img-relay.rongrong.workers.dev/
+      #- USER_AGENT='Mozilla/5.0 (Android 12; Mobile; rv:68.0) Gecko/68.0 Firefox/96.0'  # default: RSStT/2.0 RSS Reader
+      #- IPV6_PRIOR=1  # default: 0
+      #- T_PROXY='socks5://172.17.0.1:1080'  # Proxy used to connect to the Telegram API
+      #- R_PROXY='socks5://172.17.0.1:1080'  # Proxy used to fetch feeds
+      #- PROXY_BYPASS_PRIVATE=1  # default: 0
+      #- PROXY_BYPASS_DOMAINS='example.com;example.net'
+      #- DEBUG=1  # debug logging, default: 0
+# ↑------ Advanced settings ------↑ #
\ No newline at end of file
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
new file mode 100644
index 0000000000..320f410844
--- /dev/null
+++ b/docs/CHANGELOG.md
@@ -0,0 +1,118 @@
+# Changelog
+
+## Multi-user, i18n, improved user-friendliness, and more (v2.0.0)
+
+Official public bot: [@RSStT_Bot](https://t.me/RSStT_Bot)
+
+**This is a major release. It introduces some major breaking changes. You must migrate to the new version manually.**  
+**PLEASE READ THE [MIGRATION GUIDE](migration-guide-v2.md) BEFORE UPDATING!**
+
+### BREAKING CHANGES
+
+- User and subscription management has been rewritten. The bot now can be used by multiple users and each subscription may have its individual monitoring interval. Thus, env variables `CHATID` and `DELAY` are deprecated and of no use.
+    - The default behavior is to run as a multi-user bot. If you still would like to limit the bot to serve you only, follow the [migration guide](migration-guide-v2.md).
+- Redis support has been dropped. Only SQLite and PostgreSQL are supported.
+
+### Additions
+
+#### Highlights
+
+- **Multi-user**: The bot can be used by any users, or in channels and groups (unless env variable `MULTIUSER` is set to `0`).
+- **I18n**: The bot now supports multiple languages. Currently, <u>English (en)</u>, <u>Simplified Chinese (简体中文, zh-Hans)</u> and <u>Cantonese (廣東話, yue)</u> are supported. You can contribute by translating the bot to your language following the [translation guide](translation-guide.md).
+- **User-friendly**: You can use most commands interactively, no need to remember their syntax.
+- **HTTP Caching**: The bot has implemented the necessary parts of [RFC7234](https://datatracker.ietf.org/doc/html/rfc7234) to "cache" feeds. It can reduce the servers loads of both the bot and the feed provider.
+
+#### Other additions
+
+- **Customizing subscriptions**: Subscriptions can be customized. Currently, only the settings below can be customized. Other settings are WIP.
+    - **Pausing**: You can deactivate a subscription. In this way, you can make the bot pause to send updates of it.
+    - **Muting**: You can mute a subscription. In this way, when the bot sends updates of it, silent messages will be sent. (You will still receive notifications, but no sound.)
+    - **Interval**: You can change the monitoring interval of a subscription.
+- **Documentation**: The bot now has documentation. You can find it at [docs]().
+
+### Enhancements
+
+- **Better feed history management**: All posts in a feed are now hashed and stored. This allows you to subscribe to almost any feeds without missing posts.
+- **Better error handling**: The bot now has better error handling. It will now try to recover from errors and retry.
+- **Better logging**: The bot now has better logging.
+- **Better performance**: The bot now has a better performance.
+- **Dependence bump**: Dependencies have been bumped to the latest version. Potential security vulnerabilities have been fixed.
+- **Proxy bypassing**: If env variable `PROXY_BYPASS_PRIVATE` is set, the bot will bypass proxy for private IPs. And will bypass proxy for domains listed in env variable `PROXY_BYPASS_DOMAINS`.
+- **Bugfixes**: A few bugfixes.
+
+## Rushed release to fix login (v1.6.1)
+
+**This is a rushed release. It bumps the dependency `telethon` to the latest version. Please upgrade to this version immediately to avoid being unable to login due to the outdated dependency.**
+
+The bot is currently being actively developed on the `multiuser` branch but has not been merged back yet to avoid introducing breaking changes too early. If you would like to try the multi-user version, there is a public demo [@RSStT_Bot](https://t.me/RSStT_Bot).
+
+### Additions
+
+- `.env` file support (only for manual execution, not for docker)
+- Unescape HTML-escaped post title
+- Use the title as the content of a post if the latter is of no text
+
+### Enhancements
+
+- Minor bug fixes
+- Introduce some workarounds to avoid being flood-controlled frequently
+- Introduce some deps to speed up HTTP requests
+
+## Switching to MTProto, OPML support, and more (v1.6.0)
+
+### BREAKING CHANGES
+
+- The telegram bot library has been migrated from `python-telegram-bot` (which uses HTTP Bot API and is synchronous) to `telethon` (which uses MTProto Bot API and is asynchronous)
+    - However, to use MTProto Bot API, an API key is needed. The bot has 7 built-in API keys (collected from the Internet) and in most cases, it should not be unable to log in. But if so, please obtain your own API key
+      (see [docker-compose.yml.sample](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/blob/53f11a4739/docker-compose.yml.sample#L43) for details)
+
+### Additions
+
+- Thanks to the migration of the Telegram bot library, the bot can now connect to its DC directly, need not detour through the HTTP Bot API, and keep polling to get new messages. Which makes the bot receive and reply to messages more rapidly and lightweight. Even if the HTTP Bot API is down, the bot can still run unaffectedly.
+  (more details: [Advantages of MTProto over Bot API](https://docs.telethon.dev/en/latest/concepts/botapi-vs-mtproto.html#advantages-of-mtproto-over-bot-api), [MTProto vs HTTP Bot API](https://github.com/LonamiWebs/Telethon/wiki/MTProto-vs-HTTP-Bot-API))
+- Support parsing more HTML elements
+    - `<iframe>`
+    - `<video><source><source>...</video>`
+    - `<code>`
+    - `<pre>`
+- Support OPML importing and exporting
+- Support sending too-long post via Telegraph (env variable `TELEGRAPH_TOKEN` must be set)
+- Support using Redis as DB
+    - Note: This is a workaround for deploying the bot on [railway.app](), will be dropped in the future
+- Support arm64 (docker build)
+- Support resending a message using a media relay server if Telegram cannot send a message with media due to Telegram server instability or network instability between the media server and Telegram server
+- Support colored logging
+- `docker-compose.yml.sample`
+- `/version` command to check bot version
+- Automatically use proxy if global proxy (env variable `SOCKS_PROXY`/`HTTP_PROXY`) set
+
+### Enhancements
+
+- Assign feed monitoring tasks to every minute, instead of executing all at once each `DELAY`
+    - Thus, env variable `DELAY` can only be 60~3600
+    - Note: env variable `DELAY` will be deprecated in the future
+- Recognize a post by its `guid`/`id` instead of `link`
+- Simplify the output of `/list`
+- Bump Python to 3.9 (docker build)
+- Minor fixes
+
+## Complete rewrite of the post parser (v1.5.0)
+
+- The Post parser is completely rewritten, more stable, and can keep text formatting as much as possible
+- GIF Support
+- When the message is more than 10 pieces of media, send it in pieces
+- Support video and pictures to be mixed in the same message arbitrarily
+- Invalid media are no longer directly discarded, but attached to the end of the message as a link
+- Automatically determine whether the title of the RSS feed is auto-filled, if so, omit the title
+- Automatically show the author-name
+- Automatically replace emoji shortcodes with emoji
+- Automatically replace emoji images with emoji or its description text
+- When an image cannot be sent due to the instability of telegram API, the image server will be automatically replaced and resent
+    - Only for Weibo images, non-Weibo images will be attached to the end of the message as a link
+- Improve the text length counting method, no longer cause the message to be divided wrongly due to a long link URL
+- Change the user-agent, because some websites have banned the UA of Requests
+- Logging improvement
+
+## Initial release (v1.0.0)
+
+initial public release
diff --git a/docs/CHANGELOG.zh.md b/docs/CHANGELOG.zh.md
new file mode 100644
index 0000000000..190e1f35ad
--- /dev/null
+++ b/docs/CHANGELOG.zh.md
@@ -0,0 +1,118 @@
+# 更新日志
+
+## 多用户、国际化、改进的用户友好性和更多 (v2.0.0)
+
+官方的公开 bot: [@RSStT_Bot](https://t.me/RSStT_Bot)
+
+**这是一个重大的发布。它引入了一些重大变更，因此迁移至新版本需要手动完成。**  
+**更新前请务必阅读[迁移指南](migration-guide-v2.zh.md)！**
+
+### 重大变更
+
+- 重写用户及订阅管理。Bot 现在可以被多个用户同时使用，且各个订阅都可以独立设置监视间隔。因此，环境变量 `CHATID` 和 `DELAY` 已经被弃用且不再有效。
+    - 默认情况下，bot 将作为多用户机器人运行。如果你仍然希望限制 bot 仅为你服务，请按照[迁移指南](migration-guide-v2.zh.md)进行设置。
+- 不再支持 Redis，仅支持 SQLite 和 PostgreSQL。
+
+### 新特性
+
+#### 亮点
+
+- **多用户**: 任何用户都可以使用 bot，也可以在频道和群组中使用（除非环境变量 `MULTIUSER` 设置为 `0`）。
+- **国际化**: Bot 现在支持多语言。目前，<u>英语 (English, en)</u>, <u>简体中文 (zh-Hans)</u> 和 <u>粤语 (廣東話, yue)</u> 已被支持。你可以参考 [翻译指南](translation-guide.md)，通过将 bot 翻译为你的语言，为项目作出贡献。
+- **用户友好**: 你可以交互式地使用大部分命令，而不需要记住他们的语法。
+- **HTTP 缓存**: Bot 已经实现了 [RFC7234](https://datatracker.ietf.org/doc/html/rfc7234) 中的必要部分，以“缓存”订阅源。这可以帮助 bot 所在的服务器和订阅源所在的服务器降低负载。
+
+#### 其他新特性
+
+- **自定义订阅**: 订阅可被自定义。目前，只有下面列出的设置可被自定义。其他设置正在开发中。
+    - **暂停订阅**: 你可以暂停订阅。这样的话，你就可以让 bot 暂停发送订阅更新。
+    - **静音订阅**: 你可以静音订阅。这样的话，当 bot 发送更新时，会发送静音消息。(你仍然会收到通知，但不会有声音)
+    - **监视间隔**: 你可以更改订阅的监视间隔。
+- **文档**: Bot 现在有了文档。请查阅 [docs]()。
+
+### 增强
+
+- **更好的订阅源历史管理**: 订阅源中的所有文章都会经过散列并储存，这样你就可以订阅几乎任何订阅源而不必担心遗漏文章。
+- **更好的错误处理**: Bot 现在能更好地处理错误，它将会尝试恢复并重试。
+- **更好的日志**: Bot 现在能更好地记录日志。
+- **更佳的性能**: Bot 现在有着更佳的性能。
+- **依赖更新**: 依赖已被更新至最新版本。潜在的漏洞已被修复。
+- **代理绕过**: 如果设置了环境变量 `PROXY_BYPASS_PRIVATE` ，bot 会为私有网络绕过代理。在环境变量 `PROXY_BYPASS_DOMAINS` 中列出的域名也会被绕过。
+- **Bug 修复**: 修复了一些 bug。
+
+## 修复登录的仓促发布 (v1.6.1)
+
+**这是一个仓促的发布。它将依赖 `telethon` 升级到了最新版本。请立即升级到这个版本以免由于依赖过时而无法登录。**
+
+机器人正在 `multiuser` 分支上被活跃开发，但尚未被合并回来，以免过早引入重大变更。如果你想要尝试多用户版本，这里有一个公开的 demo [@RSStT_Bot](https://t.me/RSStT_Bot) 。
+
+### 新特性
+
+- `.env` 文件支持 (仅在手动执行时支持，不支持 docker)
+- 反转义受到 HTML 转义的文章标题
+- 当文章内容不含有文本时，将标题作为文章的内容
+
+### 增强
+
+- 一些小的错误修复
+- 引入了一些变通解决方案以免频繁受到泛洪控制
+- 引入了一些依赖以加速 HTTP 请求
+
+## 切换到 MTProto、OPML 支持和更多 (v1.6.0)
+
+### 重大变更
+
+- 与 Telegram 交互的库由使用 HTTP Bot API 的同步库 `python-telegram-bot` 改为使用 MTProto Bot API 的异步库 `telethon`
+    - 这引入了 API key 的需求，程序已经内置了 7 个公开的 API key，通常情况下不应无法登入。如果无法登入，可以自己申请 API key (详见 [docker-compose.yml.sample](https://github.com/Rongronggg9/RSS-to-Telegram-Bot/blob/53f11a4739/docker-compose.yml.sample#L43) 中的说明)
+
+### 新特性
+
+- 由于 Telegram bot 库的替换，bot 可以直接连接到 bot 所属的 DC，不需绕经 HTTP Bot API；也不需轮询获得消息更新，它在接收及发送消息方面都更为迅速，资源占用也更低； 即使 HTTP Bot API 宕机，bot 也可以正常工作 (详见 [Advantages of MTProto over Bot API](https://docs.telethon.dev/en/latest/concepts/botapi-vs-mtproto.html#advantages-of-mtproto-over-bot-api) 和 [MTProto vs HTTP Bot API](https://github.com/LonamiWebs/Telethon/wiki/MTProto-vs-HTTP-Bot-API))
+- 支持更多元素的解析
+    - `<iframe>`
+    - `<video><source><source>...</video>`
+    - `<code>`
+    - `<pre>`
+- 支持 OPML 导入导出
+- 支持超长文章通过 Telegraph 发送 (必须先设置 `TELEGRAPH_TOKEN` 环境变量)
+- 支持使用 redis 作为数据库
+    - 注意：这是为了在 [railway.app]() 上部署而设计的变通解决方案，未来很可能丢弃
+- 支持 arm64 (docker 构建)
+- 支持在由于 Telegram 服务器不稳定或 Telegram 服务器与媒体服务器之间的网络连接不稳定而导致 Telegram 无法发出带有媒体的消息时，使用媒体反代服务器重新发送。
+- 支持日志着色
+- `docker-compose.yml.sample`
+- 用于检查 bot 版本的 `/version` 命令
+- 如果设置了全局代理 (环境变量 `SOCKS_PROXY`/`HTTP_PROXY`)，会使用它们
+
+### 增强
+
+- 将 feed 监视任务分配到每分钟，而不是每次 `DELAY` 一次性全部执行
+    - 因此，环境变量 `DELAY` 将只能被设置为 60~3600
+    - 注意：环境变量 `DELAY` 未来将被弃用
+- 使用 `guid`/`id` 来辨识一个 post，而不是 `link`
+- 简化了 `/list` 的输出
+- 升级为 Python 3.9 (docker 构建)
+- 次要的修复
+
+## 完全重写的文章解码 (v1.5.0)
+
+- **文章解码完全重写，更加稳定及更加忠实还原原有格式**
+    - **针对大量短动态类 RSS 源进行了测试**
+    - **即使是长文 RSS 源，也可以正确处理**
+- **支持 GIF**
+- **消息多于 10 张媒体时支持分条发送**
+- **支持视频与图片任意混合于同一条消息**
+- 超限媒体不再直接丢弃，而是作为链接附加到消息末尾
+- 自动判断 RSS 源的标题是否为自动填充，并自动选择是否略去标题
+- 自动显示作者名
+- 自动替换 emoji shortcodes 为 emoji
+- 自动替换满足某些特征的表情图片为 emoji 或其描述文本
+- 因 telegram api 不稳定而无法发出图片时，自动更换图床服务器重发
+    - 仅限微博图源，非微博图源自动将所有媒体转为链接附加到消息末尾
+- 改进文本长度计数方式，不再因为链接 url 过长而导致消息被提前分割
+- 更改 user-agent，规避某些网站屏蔽 requests UA 的问题
+- 改进的日志记录
+
+## 初始发布 (v1.0.0)
+
+第一个公开发布
diff --git a/docs/FAQ.md b/docs/FAQ.md
new file mode 100644
index 0000000000..9d170981d1
--- /dev/null
+++ b/docs/FAQ.md
@@ -0,0 +1,17 @@
+# Frequently Asked Questions
+
+### **Q**: Why some posts were missing? / Why did the bot respond to me so slowly?
+
+**A**: Due to Telegram's restrictions, if too many messages are sent in a short period, the bot will get flood-controlled and have to wait for a certain time. Though the bot will retry, if still gets flood controlled, the message will be dropped. **Avoid subscribing to too many feeds, <u>especially in channels and groups</u> (they have a much stricter flood control threshold).**
+
+### **Q**: How to use the bot in my channel or group?
+
+**A**: Just add the bot to your channel or group and send commands. In a channel, "Post Messages" permission is required. If you are an anonymous administrator of a group, the bot needs to be an administrator too (no permission needed) to verify your identity.
+
+### **Q**: The command list in Telegram "Menu" is outdated!
+
+**A**: Send `/lang` and select language again. The bot will update your command list.
+
+### **Q**: How is the performance of the bot? It appears to have a slight memory leak problem.
+
+**A**: The bot is designed to be asynchronous, so it is lightweight and fast. Even if there are over 6000 feeds, the bot can still run on a single core VPS, with an incredibly low load average (~0.2) and approximate 350MB memory usage. The bot can still work fine in such a condition and its stability and usability will not be influenced. As for the memory leak problem, it is a [known issue](https://github.com/kurtmckee/feedparser/issues/287) of an upstream library `feedparser`, and it is not a bug of the bot.
\ No newline at end of file
diff --git a/docs/FAQ.zh.md b/docs/FAQ.zh.md
new file mode 100644
index 0000000000..c0be1eaf13
--- /dev/null
+++ b/docs/FAQ.zh.md
@@ -0,0 +1,17 @@
+# FAQ
+
+### **Q**: 为什么有些文章被漏掉了？ / 为什么 bot 响应我这么慢？
+
+**A**: 由于 Telegram 的限制，如果短时间内发送了太多消息，bot 会被泛洪控制，而必须等待一段时间。尽管 bot 会重试，但如果仍被泛洪控制，消息就会被丢弃。**避免订阅太多的订阅源，<u>特别是在频道和群组中</u>（它们有着严格得多的泛洪限制阈值）。**
+
+### **Q**: 如何在频道或群组里使用 bot ？
+
+**A**: 将 bot 添加到你的频道或群组里，然后发送命令就可以了。在频道里，需要「发送消息」权限。而如果你是群组的匿名管理员，bot 也需要成为管理员（不需要任何权限）才能验证你的身份。
+
+### **Q**: Telegram 「菜单」里的命令列表过时了！
+
+**A**: 发送 `/lang` 并再次设置你的语言。Bot 会为你更新命令列表。
+
+### **Q**: Bot 的性能怎么样？它看起来有轻微的内存泄漏问题。
+
+**A**: Bot 被设计为异步的，因此它轻量快速。即使订阅了超过 6000 个订阅源，bot 仍然可以在单核 VPS 上运行，并维持着令人印象深刻的 load average (约 0.2)，内存占用此时大约为 350MB。在这种情况下，bot 仍然工作得很好，且稳定性和可用性不受影响。至于内存泄漏的问题，这是上游库 `feedparser` 的一个[已知问题](https://github.com/kurtmckee/feedparser/issues/287)，并非 bot 的 bug。
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000000..8c1c898be9
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,15 @@
+# RSS to Telegram Bot Documentation
+
+## Contents
+
+| English                                          | 简体中文                                    |
+|--------------------------------------------------|-----------------------------------------|
+| [Deployment Guide](deployment-guide.md)          | 部署指南                                    |
+| [Advanced Settings](advanced-settings.md)        | 高级设置                                    |
+| [Translation Guide](translation-guide.md)        | 翻译指南                                    |
+| [Migration Guide (to v2)](migration-guide-v2.md) | [迁移指南 (至 v2)](migration-guide-v2.zh.md) |
+| [FAQ](FAQ.md)                                    | [FAQ](FAQ.zh.md)                        |
+| [CHANGELOG](CHANGELOG.md)                        | [更新日志](CHANGELOG.zh.md)                 |
+
+
+
diff --git a/docs/advanced-settings.md b/docs/advanced-settings.md
new file mode 100644
index 0000000000..00ecb44f38
--- /dev/null
+++ b/docs/advanced-settings.md
@@ -0,0 +1,62 @@
+# Advanced Settings
+
+## Env variables
+
+### Required
+
+| Key       | Description                                       | Example                                            |
+|-----------|---------------------------------------------------|----------------------------------------------------|
+| `TOKEN`   | Your bot token. Get it from [@BotFather]          | `1234567890:A1BCd2EF3gH45IJK6lMN7oPqr8ST9UvWX0Yz0` |
+| `MANAGER` | Your Telegram user ID. Get it from [@userinfobot] | `1234567890`                                       |
+
+### API settings
+
+| Key               | Description                                                 | Example                                                             | Default      |
+|-------------------|-------------------------------------------------------------|---------------------------------------------------------------------|--------------|
+| `API_ID`          | [Your Telegram API ID][telegram_api]                          | `1025907`                                                           | (predefined) |
+| `API_HASH`        | [Your Telegram API hash][telegram_api]                      | `452b0359b988148995f22ff0f4229750`                                  | (predefined) |
+| `TELEGRAPH_TOKEN` | Telegraph API access token. Get [here][telegraph_api]. [^1] | `1a23b456c78de90f1a23b456c78de90f1a23b456c78de90f1a23b456c78d` [^2] |              |
+
+[@BotFather]: https://t.me/BotFather
+
+[@userinfobot]: https://t.me/userinfobot
+
+[telegram_api]: https://core.telegram.org/api/obtaining_api_id
+
+[telegraph_api]: https://api.telegra.ph/createAccount?short_name=RSStT&author_name=Generated%20by%20RSStT&author_url=https%3A%2F%2Fgithub.com%2FRongronggg9%2FRSS-to-Telegram-Bot
+
+### Network settings
+
+| Key                    | Description                                    | Example                        | Default                |
+|------------------------|------------------------------------------------|--------------------------------|------------------------|
+| `T_PROXY`              | Proxy used to connect to the Telegram API [^3] | `socks5://172.17.0.1:1080`     |                        |
+| `R_PROXY`              | Proxy used to fetch feeds [^3]                 | `socks5://172.17.0.1:1080`     |                        |
+| `PROXY_BYPASS_PRIVATE` | Pypass proxy for private IPs or not?           | `1`                            | `0`                    |
+| `PROXY_BYPASS_DOMAINS` | Pypass proxy for listed domains                | `example.com;example.net` [^2] |                        |
+| `USER_AGENT`           | User-Agent                                     | `Mozilla/5.0`                  | `RSStT/2.0 RSS Reader` |
+| `IPV6_PRIOR`           | Enforce fetching feeds over IPv6 first or not? | `1`                            | `0`                    |
+
+### Misc settings
+
+| Key                | Description                       | Example                                       | Default                                         |
+|--------------------|-----------------------------------|-----------------------------------------------|-------------------------------------------------|
+| `MULTIUSER`        | Enable multi-user feature or not? | `0`                                           | `1`                                             |
+| `IMG_RELAY_SERVER` | Media relay server URL            | `https://images.weserv.nl/?url=`              | `https://rsstt-img-relay.rongrong.workers.dev/` |
+| `DATABASE_URL`     | Database URL [^4]                 | `postgres://user:pass@example.com:5432/table` | `sqlite://config/db.sqlite3?journal_mode=OFF`   |
+| `DEBUG`            | Enable debug logging or not?      | `1`                                           | `0`                                             |
+
+## Manager options
+
+> Manager options are options stored in the database. The bot manager can change it by using the `/set_option` command.
+
+| Key                | Description                           | Example | Default |
+|--------------------|---------------------------------------|---------|---------|
+| `default_interval` | Default feed monitoring interval [^5] | `5`     | `10`    |
+| `minimal_interval` | Minimal feed monitoring interval [^6] | `10`    | `5`     |
+
+[^1]: Refresh the page every time you get a new token. If you have a lot of subscriptions, make sure to get at least 5 tokens.
+[^2]: Can be a list, separated by `;`, `,`, `(space)`, `(linebreak)`, or `(tab)`
+[^3]: If you would like to use a proxy in a docker container, but your proxy is in your host machine, the hostname should be `172.17.0.1` (Linux) or `host.docker.internal` (macOS / Windows). Note: your proxy program should also listen to it.
+[^4]: Ref: [https://tortoise-orm.readthedocs.io/en/latest/databases.html](). Note that Railway.app will automatically fill this env variable.
+[^5]: After a user subscribes to a feed, the default monitoring interval is applied.
+[^6]: The minimal monitoring interval a user can set for a subscription. Note that the bot manager will not be limited by this value.
diff --git a/docs/deployment-guide.md b/docs/deployment-guide.md
new file mode 100644
index 0000000000..f4fdd33da7
--- /dev/null
+++ b/docs/deployment-guide.md
@@ -0,0 +1,63 @@
+# Deployment Guide
+
+## Preparation
+
+> For more env variables and detailed information, read [Advanced Settings](advanced-settings.md).
+
+1. Turn to [@BotFather](https://t.me/BotFather) to create a new bot, then get its token (env variable: `TOKEN`).
+2. Turn to [@userinfobot](https://t.me/userinfobot) to get your user ID (env variable: `MANAGER`).
+3. [Get Telegraph API access tokens](https://api.telegra.ph/createAccount?short_name=RSStT&author_name=Generated%20by%20RSStT&author_url=https%3A%2F%2Fgithub.com%2FRongronggg9%2FRSS-to-Telegram-Bot) (env variable: `TELEGRAPH_TOKEN`). Refresh the page every time you get a new token. If you have a lot of subscriptions, make sure to get at least 5 tokens.
+
+## Option 1: Docker Compose
+
+For the docker images go to: https://hub.docker.com/r/rongronggg9/rss-to-telegram
+
+### Deploy
+
+```sh
+mkdir rsstt
+cd rsstt
+wget https://raw.githubusercontent.com/Rongronggg9/RSS-to-Telegram-Bot/master/docker-compose.yml.sample -O docker-compose.yml
+vi docker-compose.yml  # fill in env variables
+docker-compose up -d
+```
+
+### Update
+
+```sh
+docker-compose down
+docker-compose pull
+docker-compose up -d
+```
+
+## Option 2: Railway.app
+
+### Deploy
+
+> Uncheck the checkbox `Private repo?`! Or you are not able to update with ease.
+
+| master                                          | dev                                       |
+|-------------------------------------------------|-------------------------------------------|
+| [![Deploy on Railway (master)][button]][master] | [![Deploy on Railway (dev)][button]][dev] |
+
+[button]: https://railway.app/button.svg
+
+[master]: https://railway.app/new/template?template=https%3A%2F%2Fgithub.com%2FRongronggg9%2FRSS-to-Telegram-Bot%2Ftree%2Fmaster&plugins=postgresql&envs=TOKEN%2CMANAGER%2CMULTIUSER%2CTELEGRAPH_TOKEN&optionalEnvs=MULTIUSER%2CTELEGRAPH_TOKEN&TOKENDesc=Your+bot+token&MANAGERDesc=Your+Telegram+user+ID&MULTIUSERDesc=If+set+to+0%2C+only+the+manager+can+use+the+bot&TELEGRAPH_TOKENDesc=To+enable+sending+via+Telegraph%2C+you+need+to+set+this&referralCode=PEOFMi
+
+[dev]: https://railway.app/new/template?template=https%3A%2F%2Fgithub.com%2FRongronggg9%2FRSS-to-Telegram-Bot%2Ftree%2Fdev&plugins=postgresql&envs=TOKEN%2CMANAGER%2CMULTIUSER%2CTELEGRAPH_TOKEN&optionalEnvs=MULTIUSER%2CTELEGRAPH_TOKEN&TOKENDesc=Your+bot+token&MANAGERDesc=Your+Telegram+user+ID&MULTIUSERDesc=If+set+to+0%2C+only+the+manager+can+use+the+bot&TELEGRAPH_TOKENDesc=To+enable+sending+via+Telegraph%2C+you+need+to+set+this&referralCode=PEOFMi
+
+### Update
+
+Turn to your GitHub repository and switch to the branch you've deployed, then click `Fetch upstream` and `Fetch and merge`.
+
+## Option 3: Dirty run
+
+Python 3.7+
+
+```sh
+git clone https://github.com/Rongronggg9/RSS-to-Telegram-Bot.git
+cd RSS-to-Telegram-Bot
+pip3 install -r requirements.txt
+vi .env # fill in env variables
+python3 -u telegramRSSbot.py
+```
diff --git a/docs/migration-guide-v2.md b/docs/migration-guide-v2.md
new file mode 100644
index 0000000000..bcb90d46ef
--- /dev/null
+++ b/docs/migration-guide-v2.md
@@ -0,0 +1,30 @@
+# Migration Guide (to v2)
+
+## Docker / Docker Compose / Dirty run
+
+1. **Turn to your bot. Send `/export` to back up your subscriptions.**
+1. (Optional) Back up your `/path/to/bot/config/`.
+1. Delete `/path/to/bot/config/`.
+1. [Redeploy](deployment-guide.md) your bot cleanly. Configure [other variables](advanced-settings.md) as you need.
+1. Turn to your bot. Send `/import` to import your subscriptions again.
+
+## Railway.app
+
+1. **Turn to your bot. Send `/export` to back up your subscriptions.**
+1. Turn to your Railway project.
+1. (Optional) Back up your Redis database if you know how to do it.
+1. Turn to the `Settings` page, switch to the `Danger` tab. `Remove` the Redis plugin.
+1. Click the `Add Plugin` button on the bottom left, select `Add PostgreSQL`.
+1. Turn to the `Variables` page. `Delete` the `CHATID` and `DELAY` variables. Configure [other variables](advanced-settings.md) as you need.
+1. Turn to your forked GitHub repository. Switch to the branch you've deployed, then click `Fetch upstream` and `Fetch and merge`.
+1. Wait for your Railway project to be updated.
+1. Turn to your bot. Send `/import` to import your subscriptions again.
+
+## If you're using the `multiuser` branch...
+
+Make sure you switch to the `master` or `dev` branch. For Railway, you can do this by switching the deployment triggers (`Deployments` -> `Triggers` -> `Branches` -> add a new trigger and delete the old one) **BEFORE START MIGRATING ACCORDING TO THE GUIDE**.
+
+## If you still would like to limit the bot to serve you only...
+
+Set the env variable `MULTIUSER` to `1`.  
+However, if you need to use the bot in a channel or group, you cannot switch off the multi-user mode for the moment. As a temporary workaround, you may first switch on the multi-user mode, subscribe to the feeds you like in your channel or group, and then switch off the multi-user mode.
diff --git a/docs/migration-guide-v2.zh.md b/docs/migration-guide-v2.zh.md
new file mode 100644
index 0000000000..f3d013ca8e
--- /dev/null
+++ b/docs/migration-guide-v2.zh.md
@@ -0,0 +1,30 @@
+# 迁移指南 (至 v2)
+
+## Docker / Docker Compose / 脏运行
+
+1. **转到你的 bot。发送 `/export` 来备份你的订阅。**
+1. (可选) 备份你的 `/path/to/bot/config/`。
+1. 删除 `/path/to/bot/config/`。
+1. 从头[重新部署](deployment-guide.md)你的 bot。
+1. 转到你的 bot。发送 `/import` 来重新导入你的订阅。按需配置[其他环境变量](advanced-settings.md)。
+
+## Railway.app
+
+1. **转到你的 bot。发送 `/export` 来备份你的订阅。**
+1. 转到你的 Railway 项目。
+1. (可选) 备份你的 Redis 数据库，如果你知道怎么做的话。
+1. 转到设置 (`Settings`) 页，切换到危险 (`Danger`) 标签。移除 (`Remove`) Redis 插件。
+1. 点击左下角的添加插件 (`Add Plugin`) 按钮，选择添加 PostgreSQL (`Add PostgreSQL`)。
+1. 转到变量 (`Variables`) 页。删除 (`Delete`) 环境变量 `CHATID` 和 `DELAY` 。按需配置[其他环境变量](advanced-settings.md)。
+1. 转到你在 GitHub 上 fork 的仓库。切换到你已部署的分支，然后点击 `Fetch upstream` 和 `Fetch and merge`。
+1. 等待你的 Railway 项目更新。
+1. 转到你的 bot。发送 `/import` 来重新导入你的订阅。
+
+## 如果你正在使用 `multiuser` 分支…
+
+确保切换至 `master` 或 `dev` 分支。对于 Railway 来说，你可以通过切换部署触发器来做到这一点 (`Deployments` -> `Triggers` -> `Branches` -> 添加一个新的触发器并删除旧的)，**切记必须在开始根据本指南迁移之前完成这一步**。
+
+## 如果你仍然希望限制 bot 仅为你服务…
+
+将环境变量 `MULTIUSER` 设置为 `1`。  
+然而，如果你需要在频道或群组里使用 bot，你暂时还不能关闭多用户模式。作为一个临时变通方案，你可以先打开多用户模式，在你的频道或群组里订阅你喜欢的订阅源，再关闭多用户模式。
diff --git a/resources/GZMTR_Pill.png b/docs/resources/GZMTR_Pill.png
similarity index 100%
rename from resources/GZMTR_Pill.png
rename to docs/resources/GZMTR_Pill.png
diff --git a/resources/RSStT_icon.svg b/docs/resources/RSStT_icon.svg
similarity index 100%
rename from resources/RSStT_icon.svg
rename to docs/resources/RSStT_icon.svg
diff --git a/resources/example1.png b/docs/resources/example1.png
similarity index 100%
rename from resources/example1.png
rename to docs/resources/example1.png
diff --git a/resources/example2.png b/docs/resources/example2.png
similarity index 100%
rename from resources/example2.png
rename to docs/resources/example2.png
diff --git a/resources/example3.png b/docs/resources/example3.png
similarity index 100%
rename from resources/example3.png
rename to docs/resources/example3.png
diff --git a/docs/resources/example4.png b/docs/resources/example4.png
new file mode 100644
index 0000000000..1325e0808a
Binary files /dev/null and b/docs/resources/example4.png differ
diff --git a/resources/rsstt.png b/docs/resources/rsstt.png
similarity index 100%
rename from resources/rsstt.png
rename to docs/resources/rsstt.png
diff --git a/docs/translation-guide.md b/docs/translation-guide.md
new file mode 100644
index 0000000000..4871eae2bd
--- /dev/null
+++ b/docs/translation-guide.md
@@ -0,0 +1,34 @@
+# Translation Guide
+
+You can contribute by helping us to translate the bot to your language.
+
+## Steps
+
+1. Copy the [src/i18n/](../src/i18n)`en.json` to [src/i18n/](../src/i18n)`<lang_code>.json`.
+
+2. Ensure the following keys are correct:
+
+| key                | e.g. 1    | e.g. 2               | e.g. 3      | e.g. 4                |
+|--------------------|-----------|----------------------|-------------|-----------------------|
+| "lang_code"[^1]    | "en"      | "zh-Hans"            | "yue"[^2]   | "zh-Hant"             |
+| "iso_639_code"[^3] | "en"      | "zh"                 | "yue"       | ""[^4]                |
+| "language_name"    | "English" | "Simplified Chinese" | "Cantonese" | "Traditional Chinese" |
+| "lang_native_name" | "English" | "简体中文"               | "廣東話"       | "正體中文"                |
+
+3. Translate other keys to your language.
+
+4. Commit your translation and create a Pull Request.
+
+## Weblate
+
+> Experimental
+
+https://hosted.weblate.org/projects/rss-to-telegram-bot/
+
+[^1]: Shorter is better. Usually, it's the same as `iso_639_code`. However, if a language does have multiple common variants and of which no one can be a common standard, consider using an extended [IETF language tag](https://en.wikipedia.org/wiki/IETF_language_tag) instead. Please make sure the language code is [IANA-registered](https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry) and not deprecated or not about to be deprecated.
+
+[^2]: `yue` is a valid ISO 639-3 code, while `zh-yue` is non-standard.
+
+[^3]: Use for fallback. If your language has an ISO 639-1 code, use it. Otherwise, use an ISO 639-2/3 code. Ref: [List of ISO 639-1 codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)
+
+[^4]: If a language has multiple variants, only the most widely-used one can set `iso_639_code`.
diff --git a/requirements.txt b/requirements.txt
index 30ea973298..719263c16d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -9,22 +9,26 @@ listparser==0.18
 #pillow==8.3.2
 bs4==0.0.1
 beautifulsoup4==4.10.0
-lxml==4.6.4
+lxml==4.7.1
 fuzzywuzzy==0.18.0
-emoji==1.6.1
+emoji==1.6.3
 
 # db
-redis==4.0.2
+tortoise-orm[asyncpg,accel]==0.18.1
+aerich==0.6.2
 
 # network
 aiohttp[speedups]==3.8.1
 aiohttp-socks==0.7.1
 aiohttp-retry==2.4.6
-python-socks[asyncio]==2.0.0
+python-socks[asyncio]==2.0.3
+aiodns==3.0.0
 
 # utils
-fasteners==0.16.3
 colorlog==6.6.0
 APScheduler==3.8.1
 python-dotenv==0.19.2
-readerwriterlock==1.0.9
\ No newline at end of file
+readerwriterlock==1.0.9
+multidict==6.0.2
+attrs==21.4.0
+uvloop==0.16.0; python_version>="3.7" and sys_platform!='win32' and sys_platform!='cygwin' and sys_platform!='cli'
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/command/__init__.py b/src/command/__init__.py
new file mode 100644
index 0000000000..ce129f3f43
--- /dev/null
+++ b/src/command/__init__.py
@@ -0,0 +1 @@
+from . import management, opml, sub, utils, monitor, customization, administration
diff --git a/src/command/administration.py b/src/command/administration.py
new file mode 100644
index 0000000000..4e317a9247
--- /dev/null
+++ b/src/command/administration.py
@@ -0,0 +1,106 @@
+import asyncio
+from typing import Union, Optional
+from telethon import events
+from telethon.tl.patched import Message
+
+from src import web, db
+from src.i18n import i18n
+from src.parsing.post import get_post_from_entry
+from .utils import command_gatekeeper, parse_command, logger
+from . import inner
+
+
+@command_gatekeeper(only_manager=True)
+async def cmd_set_option(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    args = parse_command(event.raw_text)
+    if len(args) < 3:  # return options info
+        options = db.EffectiveOptions.options
+        msg = (
+                f'<b>{i18n[lang]["current_options"]}</b>\n\n'
+                + '\n'.join(f'<code>{key}</code> = <code>{value}</code> '
+                            f'({i18n[lang]["option_value_type"]}: <code>{type(value).__name__}</code>)'
+                            for key, value in options.items())
+                + '\n\n' + i18n[lang]['set_option_cmd_usage_prompt_html']
+        )
+        await event.respond(msg, parse_mode='html')
+        return
+    key = args[1]
+    value = args[2]
+
+    try:
+        await db.EffectiveOptions.set(key, value)
+    except KeyError:
+        await event.respond(f'ERROR: {i18n[lang]["option_key_invalid"]}')
+        return
+    except ValueError:
+        await event.respond(f'ERROR: {i18n[lang]["option_value_invalid"]}')
+        return
+
+    logger.info(f"Set option {key} to {value}")
+
+    if key == 'default_interval':
+        all_feeds = await db.Feed.all()
+        await asyncio.gather(
+            *(inner.utils.update_interval(feed) for feed in all_feeds)
+        )
+        logger.info(f"Flushed the interval of all feeds")
+
+    await event.respond(f'<b>{i18n[lang]["option_updated"]}</b>\n'
+                        f'<code>{key}</code> = <code>{value}</code>',
+                        parse_mode='html')
+
+
+@command_gatekeeper(only_manager=True)
+async def cmd_test(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    args = parse_command(event.raw_text)
+    if len(args) < 2:
+        await event.respond(i18n[lang]['test_cmd_usage_prompt_html'], parse_mode='html')
+        return
+    url = args[1]
+
+    if len(args) > 2 and args[2] == 'all':
+        start = 0
+        end = None
+    elif len(args) == 3:
+        start = int(args[2])
+        end = int(args[2]) + 1
+    elif len(args) == 4:
+        start = int(args[2])
+        end = int(args[3]) + 1
+    else:
+        start = 0
+        end = 1
+
+    uid = event.chat_id
+
+    try:
+        wf = await web.feed_get(url, web_semaphore=False, lang=lang)
+        rss_d = wf.rss_d
+
+        if rss_d is None:
+            await event.respond(wf.msg)
+            return
+
+        if start >= len(rss_d.entries):
+            start = 0
+            end = 1
+        elif end is not None and start > 0 and start >= end:
+            end = start + 1
+
+        entries_to_send = rss_d.entries[start:end]
+
+        await asyncio.gather(
+            *(__send(uid, entry, rss_d.feed.title, url) for entry in entries_to_send)
+        )
+
+    except Exception as e:
+        logger.warning(f"Sending failed:", exc_info=e)
+        await event.respond('ERROR: ' + i18n[lang]['internal_error'])
+        return
+
+
+async def __send(uid, entry, feed_title, link):
+    post = get_post_from_entry(entry, feed_title, link)
+    await post.generate_message()
+    logger.debug(f"Sending {entry['title']} ({entry['link']})...")
+    await post.send_message(uid)
diff --git a/src/command/customization.py b/src/command/customization.py
new file mode 100644
index 0000000000..071af6660b
--- /dev/null
+++ b/src/command/customization.py
@@ -0,0 +1,152 @@
+from typing import Union, Optional
+from telethon import events, Button
+from telethon.tl.patched import Message
+
+from . import inner
+from .utils import command_gatekeeper, parse_sub_customization_callback_data, parse_callback_data_with_page
+from src import db
+from src.i18n import i18n
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_set_or_callback_get_set_page(event: Union[events.NewMessage.Event, Message, events.CallbackQuery.Event],
+                                           *_,
+                                           lang: Optional[str] = None,
+                                           page: Optional[int] = None,
+                                           **__):  # command: /set ; callback data: get_set_page_{page_number}
+    is_callback = isinstance(event, events.CallbackQuery.Event)
+    user_id = event.chat_id
+    if not page:
+        page, _ = parse_callback_data_with_page(event.data) if is_callback else (1, None)
+
+    have_subs = await inner.utils.have_subs(event.chat_id)
+    if not have_subs:
+        msg = i18n[lang]['no_subscription']
+        buttons = None
+    else:
+        msg = i18n[lang]['set_choose_sub_prompt']
+        buttons = await inner.utils.get_sub_choosing_buttons(user_id, page=page, lang=lang,
+                                                             callback='set',
+                                                             get_page_callback='get_set_page')
+
+    await event.respond(msg, buttons=buttons) if not is_callback else \
+        await event.edit(msg, buttons=buttons)
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_set(event: events.CallbackQuery.Event,
+                       *_,
+                       lang: Optional[str] = None,
+                       **__):  # callback data = set_{sub_id}[_{action}[_{param}]][|{page_number}]
+
+    sub_id, action, param, page = parse_sub_customization_callback_data(event.data)
+
+    if sub_id is None:
+        await cmd_set_or_callback_get_set_page.__wrapped__(event, lang=lang, page=page)
+        return
+
+    sub = await db.Sub.get_or_none(id=sub_id, user=event.chat_id).prefetch_related('feed')
+    if sub is None:
+        await event.edit(i18n[lang]['subscription_not_exist'])
+        return
+
+    if (
+            action is None
+            or (action == 'interval' and isinstance(param, int))
+            or action == 'notify'
+            or action == 'activate'
+    ):
+        if action == 'interval' and isinstance(param, int):
+            await inner.customization.set_sub_interval(sub, param)
+        elif action == 'notify':
+            await inner.customization.set_sub_notification(sub)
+        elif action == 'activate':
+            await inner.customization.set_sub_activate(sub)
+
+        info = await inner.customization.get_sub_info(sub, lang)
+        buttons = await inner.customization.get_sub_customization_buttons(sub, lang=lang, page=page)
+        await event.edit(info, buttons=buttons, parse_mode='html')
+        return
+
+    if action == 'interval':
+        msg = i18n[lang]['set_interval_prompt']
+        buttons = await inner.customization.get_set_interval_buttons(sub, lang=lang, page=page)
+        await event.edit(msg, buttons=buttons)
+        return
+
+    await event.edit(i18n[lang]['action_invalid'])
+    return
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_activate_or_deactivate_subs(event: Union[events.NewMessage.Event, Message],
+                                          activate: bool,
+                                          *_,
+                                          lang: Optional[str] = None,
+                                          **__):  # cmd: activate_subs | deactivate_subs
+    await callback_get_activate_or_deactivate_page.__wrapped__(event, activate, lang=lang, page=1)
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_get_activate_or_deactivate_page(event: Union[events.CallbackQuery.Event,
+                                                                events.NewMessage.Event,
+                                                                Message],
+                                                   activate: bool,
+                                                   *_,
+                                                   lang: Optional[str] = None,
+                                                   page: Optional[int] = None,
+                                                   **__):  # callback data: get_(activate|deactivate)_page_{page}
+    event_is_msg = not isinstance(event, events.CallbackQuery.Event)
+    if page is None:
+        page = int(event.data.decode().strip().split('_')[-1]) if not event_is_msg else 1
+    have_subs = await inner.utils.have_subs(event.chat_id)
+    if not have_subs:
+        no_subscription_msg = i18n[lang]['no_subscription']
+        await (event.respond(no_subscription_msg) if event_is_msg
+               else event.edit(no_subscription_msg))
+        return
+    sub_buttons = await inner.utils.get_sub_choosing_buttons(
+        event.chat_id,
+        page=page,
+        callback='activate_sub' if activate else 'deactivate_sub',
+        get_page_callback='get_activate_page' if activate else 'get_deactivate_page',
+        lang=lang,
+        rows=11,
+        state=0 if activate else 1
+    )
+    msg = i18n[lang]['choose_sub_to_be_activated' if sub_buttons else 'all_subs_are_activated'] if activate \
+        else i18n[lang]['choose_sub_to_be_deactivated' if sub_buttons else 'all_subs_are_deactivated']
+    activate_or_deactivate_all_subs_str = 'activate_all_subs' if activate else 'deactivate_all_subs'
+    buttons = (
+            (
+                (Button.inline(i18n[lang][activate_or_deactivate_all_subs_str],
+                               data=activate_or_deactivate_all_subs_str),),
+            )
+            + sub_buttons
+    ) if sub_buttons else None
+    await (event.respond(msg, buttons=buttons) if event_is_msg
+           else event.edit(msg, buttons=buttons))
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_activate_or_deactivate_all_subs(event: events.CallbackQuery.Event,
+                                                   activate: bool,
+                                                   *_,
+                                                   lang: Optional[str] = None,
+                                                   **__):  # callback data: (activate|deactivate)_all_subs
+    await inner.utils.activate_or_deactivate_all_subs(event.chat_id, activate=activate)
+    await callback_get_activate_or_deactivate_page.__wrapped__(event, activate, lang=lang, page=1)
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_activate_or_deactivate_sub(event: events.CallbackQuery.Event,
+                                              activate: bool,
+                                              *_,
+                                              lang: Optional[str] = None,
+                                              **__):  # callback data: (activate|deactivate)_sub_{id}|{page}
+    sub_id, page = parse_callback_data_with_page(event.data)
+    unsub_res = await inner.utils.activate_or_deactivate_sub(event.chat_id, sub_id, activate=activate)
+    if unsub_res is None:
+        await event.answer('ERROR: ' + i18n[lang]['subscription_not_exist'], alert=True)
+        return
+    await callback_get_activate_or_deactivate_page.__wrapped__(event, activate, lang=lang, page=page)
diff --git a/src/command/inner/__init__.py b/src/command/inner/__init__.py
new file mode 100644
index 0000000000..fd4651e8b1
--- /dev/null
+++ b/src/command/inner/__init__.py
@@ -0,0 +1 @@
+from . import sub, utils, customization
diff --git a/src/command/inner/customization.py b/src/command/inner/customization.py
new file mode 100644
index 0000000000..a8c1ddb1a9
--- /dev/null
+++ b/src/command/inner/customization.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+from typing import Union, Optional
+
+from telethon import Button
+from telethon.tl.types import KeyboardButtonCallback
+
+from src import db, env
+from src.i18n import i18n
+from .utils import arrange_grid, update_interval, activate_or_deactivate_sub
+
+
+async def get_sub_info(sub: db.Sub,
+                       lang: Optional[str] = None) -> str:
+    info = (
+        f"<b>{i18n[lang]['subscription_info']}</b>\n\n"
+        f"{i18n[lang]['subscription_title']}: {sub.title or sub.feed.title}\n"
+        f"{i18n[lang]['feed_url']}: {sub.feed.link}\n"
+    )
+    return info
+
+
+async def get_sub_customization_buttons(sub: db.Sub,
+                                        lang: Optional[str] = None,
+                                        page: Optional[int] = None) -> tuple[tuple[KeyboardButtonCallback, ...], ...]:
+    page = page or 1
+    buttons = (
+        (
+            Button.inline(i18n[lang]['status'] + ': ' +
+                          i18n[lang]['status_activated' if sub.state == 1 else 'status_deactivated'],
+                          data=f'set_{sub.id}_activate|{page}'),
+        ),
+        (
+            Button.inline(i18n[lang]['notification'] + ': ' +
+                          i18n[lang]['notification_normal' if sub.notify else 'notification_muted'],
+                          data=f'set_{sub.id}_notify|{page}'),
+            Button.inline(i18n[lang]['monitor_interval'] + ': ' +
+                          str(sub.interval or db.EffectiveOptions.default_interval),
+                          data=f'set_{sub.id}_interval|{page}'),
+        ),
+        (
+            Button.inline(f'< {i18n[lang]["back"]}', data=f'get_set_page_{page}'),
+        )
+    )
+    return buttons
+
+
+async def get_set_interval_buttons(sub: Union[db.Sub, int],
+                                   lang: Optional[str] = None,
+                                   page: Optional[int] = None) -> tuple[tuple[KeyboardButtonCallback, ...], ...]:
+    sub_id = sub if isinstance(sub, int) else sub.id
+    page = page or 1
+
+    minimal_interval: int = db.EffectiveOptions.minimal_interval
+    default_interval: int = db.EffectiveOptions.default_interval
+
+    if sub.user_id == env.MANAGER:
+        minimal_interval = min(minimal_interval, 5)
+
+    interval_range = list(range(minimal_interval, minimal_interval + 125, 5))
+    try:
+        interval_range.remove(sub.interval or default_interval)
+    except ValueError:
+        pass
+
+    buttons = arrange_grid(
+        to_arrange=(
+            Button.inline(str(interval), data=f'set_{sub_id}_interval_{interval}|{page}')
+            for interval in interval_range[:24]
+        ),
+        columns=4
+    ) + ((Button.inline(f'< {i18n[lang]["back"]}', data=f'set_{sub_id}|{page}'),),)
+    return buttons
+
+
+async def set_sub_interval(sub: db.Sub,
+                           interval: int) -> db.Sub:
+    minimal_interval = db.EffectiveOptions.minimal_interval
+    if interval < minimal_interval and sub.user_id != env.MANAGER:
+        interval = minimal_interval
+
+    if interval == sub.interval:
+        return sub
+
+    sub.interval = interval
+    await sub.save()
+    await update_interval(sub.feed, interval)
+
+    return sub
+
+
+async def set_sub_notification(sub: db.Sub) -> db.Sub:
+    sub.notify = not sub.notify
+    await sub.save()
+
+    return sub
+
+
+async def set_sub_activate(sub: db.Sub) -> db.Sub:
+    activated = sub.state == 1
+    await activate_or_deactivate_sub(sub.user_id, sub, activate=not activated)
+
+    return sub
diff --git a/src/command/inner/sub.py b/src/command/inner/sub.py
new file mode 100644
index 0000000000..987ea34d7f
--- /dev/null
+++ b/src/command/inner/sub.py
@@ -0,0 +1,235 @@
+from __future__ import annotations
+from typing import Union, Optional
+from collections.abc import Sequence
+
+import asyncio
+from datetime import datetime
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+
+from src import db, web
+from src.i18n import i18n
+from ..utils import logger, escape_html
+from .utils import get_hash, update_interval, list_sub, get_http_caching_headers, filter_urls
+
+with open('src/opml_template.opml', 'r') as __template:
+    OPML_TEMPLATE = __template.read()
+
+
+async def sub(user_id: int, feed_url: str, lang: Optional[str] = None) -> dict[str, Union[int, str, db.Sub, None]]:
+    ret = {'url': feed_url,
+           'sub': None,
+           'status': -1,
+           'msg': None}
+
+    try:
+        feed = await db.Feed.get_or_none(link=feed_url)
+        _sub = None
+        created_new_sub = False
+
+        if feed:
+            _sub = await db.Sub.get_or_none(user=user_id, feed=feed)
+        if not feed or feed.state == 0:
+            wf = await web.feed_get(feed_url, lang=lang)
+            rss_d = wf.rss_d
+            ret['status'] = wf.status
+            ret['msg'] = wf.msg
+            feed_url_original = feed_url
+            ret['url'] = feed_url = wf.url  # get the redirected url
+
+            if rss_d is None:
+                logger.warning(f'Sub {feed_url} for {user_id} failed')
+                return ret
+
+            if feed_url_original != feed_url:
+                logger.info(f'Sub {feed_url_original} redirected to {feed_url}')
+                if feed:
+                    await migrate_to_new_url(feed, feed_url)
+
+            # need to use get_or_create because we've changed feed_url to the redirected one
+            feed, created_new_feed = await db.Feed.get_or_create(defaults={'title': rss_d.feed.title}, link=feed_url)
+            if created_new_feed or feed.state == 0:
+                feed.state = 1
+                feed.error_count = 0
+                feed.next_check_time = None
+                http_caching_d = get_http_caching_headers(wf.headers)
+                feed.etag = http_caching_d['ETag']
+                feed.last_modified = http_caching_d['Last-Modified']
+                feed.entry_hashes = [get_hash(entry.get('guid') or entry.get('link')) for entry in rss_d.entries]
+                await feed.save()  # now we get the id
+                db.effective_utils.EffectiveTasks.update(feed.id)
+
+        if not _sub:  # create a new sub if needed
+            _sub, created_new_sub = await db.Sub.get_or_create(user_id=user_id, feed=feed)
+            _sub.feed = feed  # thus we don't need to fetch_related
+
+        if not created_new_sub:
+            ret['sub'] = None
+            ret['msg'] = 'ERROR: ' + i18n[lang]['already_subscribed']
+            return ret
+
+        ret['sub'] = _sub
+        logger.info(f'Subed {feed_url} for {user_id}')
+        return ret
+
+    except Exception as e:
+        ret['msg'] = 'ERROR: ' + i18n[lang]['internal_error']
+        logger.warning(f'Sub {feed_url} for {user_id} failed: ', exc_info=e)
+        return ret
+
+
+async def subs(user_id: int,
+               feed_urls: Sequence[str],
+               lang: Optional[str] = None,
+               bypass_url_filter: bool = False) \
+        -> Optional[dict[str, Union[dict[str, Union[int, str, db.Sub, None]], str]]]:
+    feed_urls = filter_urls(feed_urls) if not bypass_url_filter else feed_urls
+    if not feed_urls:
+        return None
+
+    result = await asyncio.gather(*(sub(user_id, url, lang=lang) for url in feed_urls))
+
+    success = tuple(sub_d for sub_d in result if sub_d['sub'])
+    failure = tuple(sub_d for sub_d in result if not sub_d['sub'])
+
+    msg = (
+            (f'<b>{i18n[lang]["sub_successful"]}</b>\n' if success else '')
+            + '\n'.join(f'<a href="{sub_d["sub"].feed.link}">{escape_html(sub_d["sub"].feed.title)}</a>'
+                        for sub_d in success)
+            + ('\n\n' if success and failure else '')
+            + (f'<b>{i18n[lang]["sub_failed"]}</b>\n' if failure else '')
+            + '\n'.join(f'{escape_html(sub_d["url"])} ({sub_d["msg"]})' for sub_d in failure)
+    )
+
+    ret = {'sub_d_l': result, 'msg': msg}
+
+    return ret
+
+
+async def unsub(user_id: int, feed_url: str = None, sub_id: int = None, lang: Optional[str] = None) \
+        -> dict[str, Union[str, db.Sub, None]]:
+    ret = {'url': feed_url,
+           'sub': None,
+           'msg': None}
+
+    if (feed_url and sub_id) or not (feed_url or sub_id):
+        ret['msg'] = 'ERROR: ' + i18n[lang]['internal_error']
+        return ret
+
+    try:
+        if feed_url:
+            feed: db.Feed = await db.Feed.get_or_none(link=feed_url)
+            sub_to_delete: Optional[db.Sub] = await feed.subs.filter(user=user_id).first() if feed else None
+        else:  # elif sub_id:
+            sub_to_delete: db.Sub = await db.Sub.get_or_none(id=sub_id, user=user_id).prefetch_related('feed')
+            feed: Optional[db.Feed] = await sub_to_delete.feed if sub_to_delete else None
+
+        if sub_to_delete is None or feed is None:
+            ret['msg'] = 'ERROR: ' + i18n[lang]['subscription_not_exist']
+            return ret
+
+        await sub_to_delete.delete()
+        await update_interval(feed=feed)
+
+        sub_to_delete.feed = feed
+        ret['sub'] = sub_to_delete
+        ret['url'] = feed.link
+        logger.info(f'Unsubed {feed.link} for {user_id}')
+        return ret
+
+    except Exception as e:
+        ret['msg'] = 'ERROR: ' + i18n[lang]['internal_error']
+        logger.warning(f'Unsub {feed_url} for {user_id} failed: ', exc_info=e)
+        return ret
+
+
+async def unsubs(user_id: int,
+                 feed_urls: Sequence[str] = None,
+                 sub_ids: Sequence[int] = None,
+                 lang: Optional[str] = None,
+                 bypass_url_filter: bool = False) \
+        -> Optional[dict[str, Union[dict[str, Union[int, str, db.Sub, None]], str]]]:
+    feed_urls = filter_urls(feed_urls) if not bypass_url_filter else feed_urls
+    if not (feed_urls or sub_ids):
+        return None
+
+    coroutines = (
+            (tuple(unsub(user_id, feed_url=url, lang=lang) for url in feed_urls) if feed_urls else tuple())
+            + (tuple(unsub(user_id, sub_id=sub_id, lang=lang) for sub_id in sub_ids) if sub_ids else tuple())
+    )
+
+    result = await asyncio.gather(*coroutines)
+
+    success = tuple(unsub_d for unsub_d in result if unsub_d['sub'])
+    failure = tuple(unsub_d for unsub_d in result if not unsub_d['sub'])
+
+    msg = (
+            (f'<b>{i18n[lang]["unsub_successful"]}</b>\n' if success else '')
+            + '\n'.join(f'<a href="{sub_d["sub"].feed.link}">{escape_html(sub_d["sub"].feed.title)}</a>'
+                        for sub_d in success)
+            + ('\n\n' if success and failure else '')
+            + (f'<b>{i18n[lang]["unsub_failed"]}</b>\n' if failure else '')
+            + '\n'.join(f'{escape_html(sub_d["url"])} ({sub_d["msg"]})' for sub_d in failure)
+    )
+
+    ret = {'unsub_d_l': result, 'msg': msg}
+
+    return ret
+
+
+async def unsub_all(user_id: int, lang: Optional[str] = None) \
+        -> Optional[dict[str, Union[dict[str, Union[int, str, db.Sub, None]], str]]]:
+    user_sub_list = await db.Sub.filter(user=user_id)
+    sub_ids = tuple(_sub.id for _sub in user_sub_list)
+    return await unsubs(user_id, sub_ids=sub_ids, lang=lang)
+
+
+async def export_opml(user_id: int) -> Optional[bytes]:
+    sub_list = await list_sub(user_id)
+    opml = BeautifulSoup(OPML_TEMPLATE, 'lxml-xml')
+    create_time = Tag(name='dateCreated')
+    create_time.string = datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S UTC')
+    opml.head.append(create_time)
+    empty_flags = True
+    for _sub in sub_list:
+        empty_flags = False
+        outline = Tag(name='outline', attrs={'text': _sub.feed.title, 'xmlUrl': _sub.feed.link})
+        opml.body.append(outline)
+    if empty_flags:
+        return None
+    logger.info('Exported feed(s).')
+    return opml.prettify().encode()
+
+
+async def migrate_to_new_url(feed: db.Feed, new_url: str) -> Union[bool, db.Feed]:
+    """
+    Migrate feed's link to new url, useful when a feed is redirected to a new url.
+    :param feed:
+    :param new_url:
+    :return:
+    """
+    if feed.link == new_url:
+        return False
+
+    logger.info(f'Migrating {feed.link} to {new_url}')
+    new_url_feed = await db.Feed.get_or_none(link=new_url)
+    if new_url_feed is None:  # new_url not occupied
+        feed.link = new_url
+        await feed.save()
+        return True
+
+    # new_url has been occupied by another feed
+    new_url_feed.state = 1
+    new_url_feed.title = feed.title
+    new_url_feed.entry_hashes = feed.entry_hashes
+    new_url_feed.etag = feed.etag
+    new_url_feed.last_modified = feed.last_modified
+    new_url_feed.error_count = 0
+    new_url_feed.next_check_time = None
+    await new_url_feed.save()
+
+    await feed.subs.all().update(feed=new_url_feed)  # migrate all subs to the new feed
+
+    await update_interval(new_url_feed)
+    await feed.delete()  # delete the old feed
+    return new_url_feed
diff --git a/src/command/inner/utils.py b/src/command/inner/utils.py
new file mode 100644
index 0000000000..3530d4ffad
--- /dev/null
+++ b/src/command/inner/utils.py
@@ -0,0 +1,229 @@
+from __future__ import annotations
+from typing import AnyStr, Any, Union, Optional
+from collections.abc import Iterable, Mapping
+
+import asyncio
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+from zlib import crc32
+from telethon import Button
+from telethon.tl.types import KeyboardButtonCallback
+
+from src import db
+from src.i18n import i18n
+
+
+def get_hash(string: AnyStr) -> str:
+    if isinstance(string, str):
+        string = string.encode('utf-8')
+    return hex(crc32(string))[2:]
+
+
+def filter_urls(urls: Optional[Iterable[str]]) -> tuple[str, ...]:
+    if not urls:
+        return tuple()
+
+    return tuple(filter(lambda x: x.startswith('http://') or x.startswith('https://'), urls))
+
+
+def get_http_caching_headers(headers: Optional[Mapping]) -> dict[str, Optional[Union[str, datetime]]]:
+    """
+    :param headers: dict of headers
+    :return: a dict containing "Etag" (`str` or `None`) and "Last-Modified" (`datetime.datetime` or `None`) headers
+    """
+    if not headers:
+        return {
+            'Last-Modified': None,
+            'ETag': None
+        }
+
+    last_modified = headers.get('Last-Modified', headers.get('Date'))
+    last_modified = parsedate_to_datetime(last_modified) if last_modified else datetime.utcnow()
+    return {
+        'Last-Modified': last_modified,
+        'ETag': headers.get('ETag')
+    }
+
+
+def arrange_grid(to_arrange: Iterable, columns: int = 8, rows: int = 13) -> Optional[tuple[tuple[Any, ...], ...]]:
+    """
+    :param to_arrange: `Iterable` containing objects to arrange
+    :param columns: 1-based, telegram limit: 8 (row 1-12), 4 (row 13)
+    :param rows: 1-based, telegram limit: 13
+    :return: grid (2D tuple) with objects arranged
+    """
+    if rows <= 0 or columns <= 0:
+        raise ValueError('Invalid grid size')
+    to_arrange = list(to_arrange)
+    counts = min(len(to_arrange), rows * columns)
+    columns = min(columns, len(to_arrange))
+    return tuple(
+        tuple(to_arrange[i:i + columns]) for i in range(0, counts, columns)
+    ) if counts > 0 else None
+
+
+async def get_sub_choosing_buttons(user_id: int,
+                                   page: int,
+                                   callback: str,
+                                   get_page_callback: Optional[str],
+                                   callback_contain_page_num: bool = True,
+                                   lang: Optional[str] = None,
+                                   rows: int = 12,
+                                   columns: int = 2,
+                                   *args, **kwargs) -> Optional[tuple[tuple[KeyboardButtonCallback, ...], ...]]:
+    """
+    :param user_id: user id
+    :param page: page number (1-based)
+    :param callback: callback data header
+    :param get_page_callback: callback data header for getting another page
+    :param callback_contain_page_num: callback data should be followed by current page number or not?
+    :param lang: language code
+    :param rows: the number of rows
+    :param columns: the number of columns
+    :param args: args for `list_sub`
+    :param kwargs: kwargs for `list_sub`
+    :return: ReplyMarkup
+    """
+    if page <= 0:
+        raise IndexError('Page number must be positive.')
+
+    user_sub_list = await list_sub(user_id, *args, **kwargs)
+    if not user_sub_list:
+        return None
+
+    subs_count_per_page = columns * rows
+    user_sub_count = len(user_sub_list)
+    page = min(user_sub_count // subs_count_per_page + bool(user_sub_count % subs_count_per_page), page)  # ensure page
+    page_start = (page - 1) * subs_count_per_page
+    page_end = page_start + subs_count_per_page
+    buttons_to_arrange = tuple(Button.inline(_sub.feed.title,
+                                             data=f'{callback}_{_sub.id}'
+                                                  + (f'|{page}' if callback_contain_page_num else ''))
+                               for _sub in user_sub_list[page_start:page_end])
+    buttons = arrange_grid(to_arrange=buttons_to_arrange, columns=columns, rows=rows)
+
+    rest_subs_count = len(user_sub_list[page * subs_count_per_page:])
+    page_buttons = []
+    if page > 1:
+        page_buttons.append(Button.inline(f'< {i18n[lang]["previous_page"]}', data=f'{get_page_callback}_{page - 1}'))
+    if rest_subs_count > 0:
+        page_buttons.append(Button.inline(f'{i18n[lang]["next_page"]} >', data=f'{get_page_callback}_{page + 1}'))
+
+    return buttons + (tuple(page_buttons),) if page_buttons else buttons
+
+
+async def update_interval(feed: Union[db.Feed, int], new_interval: Optional[int] = None, force_update: bool = False):
+    if new_interval is not None and (not isinstance(new_interval, int) or new_interval <= 0):
+        raise ValueError('`new_interval` must be `None` or a positive integer')
+
+    if isinstance(feed, int):
+        feed = await db.Feed.get_or_none(id=feed)
+
+    if feed is None:
+        return
+
+    default_interval = db.EffectiveOptions.default_interval
+    curr_interval = feed.interval or default_interval
+    default_flag = False
+
+    if not new_interval:
+        sub_exist = await feed.subs.all().exists()
+        intervals = await feed.subs.filter(state=1).values_list('interval', flat=True)
+        if not sub_exist:  # no sub subs the feed, del the feed
+            await feed.delete()
+            db.effective_utils.EffectiveTasks.delete(feed.id)
+            return
+        if not intervals:  # no active sub subs the feed, deactivate the feed
+            await deactivate_feed(feed)
+            return
+        new_interval = min(intervals, key=lambda _: default_interval if _ is None else _) or default_interval
+        default_flag = new_interval == default_interval and new_interval not in intervals
+        force_update = True
+
+    force_update = force_update and new_interval != curr_interval
+
+    if new_interval < curr_interval or force_update:  # if not force_update, will only reduce the interval
+        feed.interval = new_interval if not default_flag else None
+        await feed.save()
+        return
+
+    if db.effective_utils.EffectiveTasks.get_interval(feed.id) != new_interval:
+        db.effective_utils.EffectiveTasks.update(feed.id, new_interval)
+
+
+async def list_sub(user_id: int, *args, **kwargs) -> list[db.Sub]:
+    return await db.Sub.filter(user=user_id, *args, **kwargs).prefetch_related('feed')
+
+
+async def have_subs(user_id: int) -> bool:
+    return await db.Sub.filter(user=user_id).exists()
+
+
+async def activate_feed(feed: db.Feed) -> db.Feed:
+    if feed.state == 1:
+        return feed
+
+    feed.state = 1
+    feed.error_count = 0
+    feed.next_check_time = None
+    await feed.save()
+    await update_interval(feed)
+    return feed
+
+
+async def deactivate_feed(feed: db.Feed) -> db.Feed:
+    db.effective_utils.EffectiveTasks.delete(feed.id)
+
+    subs = await feed.subs.all()
+    if not subs:
+        await feed.delete()
+        return feed
+
+    feed.state = 0
+    feed.next_check_time = None
+    await feed.save()
+    await asyncio.gather(
+        *(activate_or_deactivate_sub(sub.user_id, sub, activate=False, _update_interval=False) for sub in subs)
+    )
+
+    return feed
+
+
+async def activate_or_deactivate_sub(user_id: int, sub: Union[db.Sub, int], activate: bool,
+                                     _update_interval: bool = True) -> Optional[db.Sub]:
+    """
+    :param user_id: user id
+    :param sub: `db.Sub` or sub id
+    :param activate: activate the sub if `Ture`, deactivate if `False`
+    :param _update_interval: update interval or not?
+    :return: the updated sub, `None` if the sub does not exist
+    """
+    if isinstance(sub, int):
+        sub = await db.Sub.get_or_none(id=sub, user_id=user_id).prefetch_related('feed')
+        if not sub:
+            return None
+    elif sub.user_id != user_id:
+        return None
+
+    sub.state = 1 if activate else 0
+    await sub.save()
+    await sub.fetch_related('feed')
+
+    if activate:
+        await activate_feed(sub.feed)
+
+    interval = sub.interval or db.EffectiveOptions.default_interval
+    if _update_interval:
+        await update_interval(sub.feed, new_interval=interval if activate else None)
+
+    return sub
+
+
+async def activate_or_deactivate_all_subs(user_id: int, activate: bool) -> tuple[Optional[db.Sub], ...]:
+    """
+    :param user_id: user id
+    :param activate: activate all subs if `Ture`, deactivate if `False`
+    :return: the updated sub, `None` if the sub does not exist
+    """
+    subs = await list_sub(user_id, state=0 if activate else 1)
+    return await asyncio.gather(*(activate_or_deactivate_sub(user_id, sub, activate=activate) for sub in subs))
diff --git a/src/command/management.py b/src/command/management.py
new file mode 100644
index 0000000000..9a71ff5373
--- /dev/null
+++ b/src/command/management.py
@@ -0,0 +1,56 @@
+from typing import Union, Optional
+from telethon import events, Button
+from telethon.tl.patched import Message
+from telethon.tl import types
+
+from src import env, db
+from src.i18n import i18n, ALL_LANGUAGES
+from .utils import command_gatekeeper, logger, set_bot_commands, get_commands_list
+from . import inner
+
+
+@command_gatekeeper(only_manager=False, ignore_tg_lang=True)
+async def cmd_start(event: Union[events.NewMessage.Event, Message], *_, lang=None, **__):
+    if lang is None:
+        await cmd_lang.__wrapped__(event)
+        return
+    await cmd_or_callback_help.__wrapped__(event, lang=lang)
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_lang(event: Union[events.NewMessage.Event, Message], *_, **__):
+    msg = '\n'.join(f"{i18n[lang]['select_lang_prompt']}"
+                    for lang in ALL_LANGUAGES)
+    buttons = inner.utils.arrange_grid((Button.inline(i18n[lang]['lang_native_name'], data=f'set_lang_{lang}')
+                                        for lang in ALL_LANGUAGES),
+                                       columns=3)
+    await event.respond(msg, buttons=buttons)
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_set_lang(event: events.CallbackQuery.Event, *_, **__):  # callback data: set_lang_{lang_code}
+    lang = event.data.decode().strip().split('set_lang_')[-1]
+    welcome_msg = i18n[lang]['welcome_prompt']
+    await db.User.update_or_create(defaults={'lang': lang}, id=event.chat_id)
+    await set_bot_commands(scope=types.BotCommandScopePeer(await event.get_input_chat()),
+                           lang_code='',
+                           commands=get_commands_list(lang=lang, manager=event.chat_id == env.MANAGER))
+    logger.info(f'Changed language to {lang} for {event.chat_id}')
+    help_button = Button.inline(text=i18n[lang]['cmd_description_help'], data='help')
+    await event.edit(welcome_msg, buttons=help_button)
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_or_callback_help(event: Union[events.NewMessage.Event, Message, events.CallbackQuery.Event],
+                               *_,
+                               lang: Optional[str] = None,
+                               **__):  # callback data: help; command: /help
+    msg = i18n[lang]['help_msg_html']
+    await event.respond(msg, parse_mode='html') \
+        if isinstance(event, events.NewMessage.Event) or not hasattr(event, 'edit') \
+        else await event.edit(msg, parse_mode='html')
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_version(event: Union[events.NewMessage.Event, Message], *_, **__):
+    await event.respond(env.VERSION)
diff --git a/src/command/monitor.py b/src/command/monitor.py
new file mode 100644
index 0000000000..1de17da40e
--- /dev/null
+++ b/src/command/monitor.py
@@ -0,0 +1,279 @@
+from __future__ import annotations
+from typing import Union
+from collections.abc import MutableMapping
+from src.compat import Final
+
+import asyncio
+from datetime import datetime, timedelta, timezone
+from email.utils import format_datetime
+from telethon.errors.rpcerrorlist import UserIsBlockedError, ChatWriteForbiddenError, UserIdInvalidError, \
+    ChannelPrivateError
+from collections import defaultdict, Counter
+
+from . import inner
+from .utils import escape_html
+from .inner.utils import get_hash, update_interval, deactivate_feed
+from src import log, db, env
+from src.exceptions import EntityNotFoundError
+from src.i18n import i18n
+from src.parsing.post import get_post_from_entry, Post
+from src.web import feed_get
+
+logger = log.getLogger('RSStT.monitor')
+
+NOT_UPDATED: Final = 'not_updated'
+CACHED: Final = 'cached'
+EMPTY: Final = 'empty'
+FAILED: Final = 'failed'
+UPDATED: Final = 'updated'
+SKIPPED: Final = 'skipped'
+
+# it may cause memory leak, but they are too small that leaking thousands of that is still not a big deal!
+__user_unsub_all_lock_bucket: dict[int, asyncio.Lock] = defaultdict(asyncio.Lock)
+__user_entity_not_found_counter = Counter()
+
+
+class MonitoringLogs:
+    monitoring_counts = 0
+    not_updated = 0
+    cached = 0
+    empty = 0
+    failed = 0
+    updated = 0
+    skipped = 0
+    timeout = 0
+
+    @classmethod
+    def log(cls, not_updated: int, cached: int, empty: int, failed: int, updated: int, skipped: int, timeout: int):
+        cls.not_updated += not_updated
+        cls.cached += cached
+        cls.empty += empty
+        cls.failed += failed
+        cls.updated += updated
+        cls.skipped += skipped
+        cls.timeout += timeout
+        logger.debug(f'Finished feeds monitoring task: '
+                     f'updated({updated}), '
+                     f'not updated({not_updated}, including {cached} cached and {empty} empty), '
+                     f'fetch failed({failed}), '
+                     f'skipped({skipped}), '
+                     f'timeout({timeout})')
+        cls.monitoring_counts += 1
+        if cls.monitoring_counts == 10:
+            cls.print_summary()
+
+    @classmethod
+    def print_summary(cls):
+        logger.info(
+            f'Monitoring tasks summary in last 10 minutes: '
+            f'updated({cls.updated}), '
+            f'not updated({cls.not_updated}, including {cls.cached} cached and {cls.empty} empty), '
+            f'fetch failed({cls.failed}), '
+            f'skipped({cls.skipped}), '
+            f'timeout({cls.timeout})'
+        )
+        cls.not_updated = cls.cached = cls.empty = cls.failed = cls.updated = cls.skipped = cls.timeout = 0
+        cls.monitoring_counts = 0
+
+
+async def run_monitor_task():
+    feed_id_to_monitor = db.effective_utils.EffectiveTasks.get_tasks()
+    if not feed_id_to_monitor:
+        return
+
+    feeds = await db.Feed.filter(id__in=feed_id_to_monitor)
+
+    logger.debug('Started feeds monitoring task.')
+    wait_for = 10 * 60
+    timeout_errors = []
+
+    result = await asyncio.gather(*(asyncio.wait_for(__monitor(feed), timeout=wait_for) for feed in feeds),
+                                  return_exceptions=True)
+
+    not_updated = 0
+    cached = 0
+    empty = 0
+    failed = 0
+    updated = 0
+    skipped = 0
+    timeout = 0
+
+    for r in result:
+        if r is NOT_UPDATED:
+            not_updated += 1
+        elif r is CACHED:
+            not_updated += 1
+            cached += 1
+        elif r is EMPTY:
+            not_updated += 1
+            empty += 1
+        elif r is UPDATED:
+            updated += 1
+        elif r is FAILED:
+            failed += 1
+        elif r is SKIPPED:
+            skipped += 1
+        elif isinstance(r, asyncio.TimeoutError):
+            timeout += 1
+            timeout_errors.append(r)
+        elif isinstance(r, BaseException):
+            raise r
+        else:
+            raise TypeError(f'Unknown monitor result type: {r}')
+
+    MonitoringLogs.log(not_updated, cached, empty, failed, updated, skipped, timeout)
+    if timeout_errors:
+        logger.error(f'Timeout detected during a feeds monitoring task, '
+                     f'totally {timeout} feed(s) timed out after {wait_for}s:')
+        for index, error in enumerate(timeout_errors):
+            logger.error(f'The TimeoutError of the {index}th feed in the task:', exc_info=error)
+
+
+async def __monitor(feed: db.Feed) -> str:
+    """
+    Monitor the update of a feed.
+
+    :param feed: the feed object to be monitored
+    :return: monitoring result
+    """
+    now = datetime.now(timezone.utc)
+    if feed.next_check_time and now < feed.next_check_time:
+        return SKIPPED  # skip this monitor task
+
+    headers = {
+        'If-Modified-Since': format_datetime(feed.last_modified or feed.updated_at)
+    }
+    if feed.etag:
+        headers['If-None-Match'] = feed.etag
+
+    wf = await feed_get(feed.link, headers=headers, verbose=False)
+    rss_d = wf.rss_d
+
+    if (rss_d is not None or wf.status == 304) and (feed.error_count > 0 or feed.next_check_time):
+        feed.error_count = 0
+        feed.next_check_time = None
+        await feed.save()
+
+    if wf.status == 304:  # cached
+        logger.debug(f'Fetched (not updated, cached): {feed.link}')
+        return CACHED
+
+    if rss_d is None:  # error occurred
+        if feed.error_count >= 100:
+            logger.error(f'Deactivated feed due to too many errors: {feed.link}')
+            await __deactivate_feed_and_notify_all(feed)
+            return FAILED
+        feed.error_count += 1
+        if feed.error_count % 20 == 0:  # error_count is always > 0
+            logger.warning(f'Fetch failed ({feed.error_count}th retry, {wf.msg}): {feed.link}')
+        if feed.error_count >= 10:  # too much error, delay next check
+            interval = feed.interval or db.EffectiveOptions.default_interval
+            next_check_interval = min(interval, 15) * min(feed.error_count // 10 + 1, 5)
+            if next_check_interval > interval:
+                feed.next_check_time = now + timedelta(minutes=next_check_interval)
+        await feed.save()
+        return FAILED
+
+    if not rss_d.entries:  # empty
+        if wf.url != feed.link:
+            await inner.sub.migrate_to_new_url(feed, wf.url)
+        logger.debug(f'Fetched (empty): {feed.link}')
+        return EMPTY
+
+    # sequence matters so we cannot use a set
+    old_hashes: list = feed.entry_hashes if isinstance(feed.entry_hashes, list) else []
+    updated_hashes = []
+    updated_entries = []
+    for entry in rss_d.entries:
+        guid = entry.get('guid') or entry.get('link')
+        if not guid:
+            continue  # IDK why there are some feeds containing entries w/o a link, should we set up a feed hospital?
+        h = get_hash(guid)
+        if h in old_hashes:
+            continue
+        updated_hashes.append(h)
+        updated_entries.append(entry)
+
+    if not updated_hashes:  # not updated
+        logger.debug(f'Fetched (not updated): {feed.link}')
+        return NOT_UPDATED
+
+    logger.debug(f'Updated: {feed.link}')
+    length = max(len(rss_d.entries) * 2, 100)
+    new_hashes = updated_hashes + old_hashes[:length - len(updated_hashes)]
+    feed.entry_hashes = new_hashes
+    http_caching_d = inner.utils.get_http_caching_headers(wf.headers)
+    feed.etag = http_caching_d['ETag']
+    feed.last_modified = http_caching_d['Last-Modified']
+    await feed.save()
+
+    if wf.url != feed.link:
+        new_url_feed = await inner.sub.migrate_to_new_url(feed, wf.url)
+        feed = new_url_feed if isinstance(new_url_feed, db.Feed) else feed
+
+    await asyncio.gather(*(__notify_all(feed, entry) for entry in updated_entries))
+
+    return UPDATED
+
+
+async def __notify_all(feed: db.Feed, entry: MutableMapping):
+    subs = await db.Sub.filter(feed=feed, state=1)
+    if not subs:  # nobody has subbed it
+        await update_interval(feed)
+    post = get_post_from_entry(entry, feed.title, feed.link)
+    await post.generate_message()
+    await asyncio.gather(
+        *(__send(sub, post) for sub in subs)
+    )
+
+
+async def __send(sub: db.Sub, post: Union[str, Post]):
+    # TODO: customized format
+    user_id = sub.user_id
+    try:
+        try:
+            await env.bot.get_input_entity(user_id)  # verify that the input entity can be get first
+        except ValueError:  # if not, self may be banned
+            if __user_entity_not_found_counter['user_id'] >= 5:  # fail for 5 times, consider been banned
+                del __user_entity_not_found_counter['user_id']
+                raise EntityNotFoundError(user_id)
+            __user_entity_not_found_counter['user_id'] += 1
+            return  # skip once
+
+        if __user_entity_not_found_counter['user_id']:  # reset the counter if success
+            del __user_entity_not_found_counter['user_id']
+
+        if isinstance(post, str):
+            await env.bot.send_message(user_id, post, parse_mode='html', silent=not sub.notify)
+            return
+        await post.send_message(user_id, silent=not sub.notify)
+    except (UserIsBlockedError, UserIdInvalidError, ChatWriteForbiddenError, ChannelPrivateError,
+            EntityNotFoundError) as e:
+        user_unsub_all_lock = __user_unsub_all_lock_bucket[user_id]
+        if user_unsub_all_lock.locked():
+            return  # no need to unsub twice!
+        async with user_unsub_all_lock:
+            # TODO: leave the group/channel if still in it
+            if await inner.utils.have_subs(user_id):
+                logger.error(f'User blocked ({e.__class__.__name__}): {user_id}')
+                await inner.sub.unsub_all(user_id)
+
+
+async def __deactivate_feed_and_notify_all(feed: db.Feed):
+    subs = await db.Sub.filter(feed=feed, state=1).prefetch_related('user')
+    await deactivate_feed(feed)
+
+    if not subs:  # nobody has subbed it or no active sub exists
+        return
+
+    await asyncio.gather(
+        *(
+            __send(
+                sub=sub,
+                post=(
+                        f'<a href="{feed.link}">{escape_html(sub.title or feed.title)}</a>\n'
+                        + i18n[sub.user.lang]['feed_deactivated_warn']
+                )
+            )
+            for sub in subs)
+    )
diff --git a/src/command/opml.py b/src/command/opml.py
new file mode 100644
index 0000000000..3a2e0e1bfc
--- /dev/null
+++ b/src/command/opml.py
@@ -0,0 +1,56 @@
+import listparser
+from datetime import datetime
+from typing import Union, Optional
+from telethon import events, Button
+from telethon.tl import types
+from telethon.tl.patched import Message
+
+from src import env
+from src.i18n import i18n
+from . import inner
+from .utils import command_gatekeeper, logger
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_import(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    await event.respond(i18n[lang]['send_opml_prompt'],
+                        buttons=Button.force_reply(single_use=True,
+                                                   selective=True,
+                                                   placeholder=i18n[lang]['send_opml_reply_placeholder']),
+                        reply_to=event.id if event.is_group else None)
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_export(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    opml_file = await inner.sub.export_opml(event.chat_id)
+    if opml_file is None:
+        await event.respond(i18n[lang]['no_subscription'])
+        return
+    await event.respond(file=opml_file,
+                        attributes=(types.DocumentAttributeFilename(
+                            f"RSStT_export_{datetime.utcnow().strftime('%Y%m%d%H%M%S')}.opml"),))
+
+
+@command_gatekeeper(only_manager=False, timeout=300)
+async def opml_import(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    reply_message: Message = await event.get_reply_message()
+    if not (event.is_private or event.is_channel and not event.is_group) and reply_message.sender_id != env.bot_id:
+        return  # must reply to the bot in a group to import opml
+    try:
+        opml_file = await event.download_media(file=bytes)
+    except Exception as e:
+        await event.reply('ERROR: ' + i18n[lang]['fetch_file_failed'])
+        logger.warning(f'Failed to get opml file from {event.chat_id}: ', exc_info=e)
+        return
+
+    reply: Message = await event.reply(i18n[lang]['processing'] + '\n' + i18n[lang]['opml_import_processing'])
+    logger.info(f'Got an opml file from {event.chat_id}')
+
+    opml_d = listparser.parse(opml_file.decode())
+    if not opml_d.feeds:
+        await reply.edit('ERROR: ' + i18n[lang]['opml_parse_error'])
+        return
+
+    import_result = await inner.sub.subs(event.chat_id, tuple(feed.url for feed in opml_d.feeds), lang=lang)
+    logger.info(f'Imported feed(s) for {event.chat_id}')
+    await reply.edit(import_result["msg"], parse_mode='html')
diff --git a/src/command/sub.py b/src/command/sub.py
new file mode 100644
index 0000000000..711d29fdee
--- /dev/null
+++ b/src/command/sub.py
@@ -0,0 +1,107 @@
+from typing import Union, Optional
+from telethon import events, Button
+from telethon.tl.patched import Message
+
+from src.i18n import i18n
+from . import inner
+from .utils import command_gatekeeper, parse_command, escape_html, parse_callback_data_with_page
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_sub(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    args = parse_command(event.raw_text)
+    filtered_urls = inner.utils.filter_urls(args)
+
+    if not filtered_urls:
+        await event.respond(i18n[lang]['sub_reply_feed_url_prompt_html'] if not event.is_channel or event.is_group
+                            else i18n[lang]['sub_usage_in_channel_html'],
+                            parse_mode='html',
+                            buttons=Button.force_reply(single_use=True,
+                                                       selective=True,
+                                                       placeholder='url1 url2 url3 ...'),
+                            reply_to=event.id if event.is_group else None)
+        return
+
+    msg: Message = await event.respond(i18n[lang]['processing'])
+
+    sub_result = await inner.sub.subs(event.chat_id, filtered_urls, lang=lang, bypass_url_filter=True)
+
+    if sub_result is None:
+        await msg.edit(i18n[lang]['sub_reply_feed_url_prompt_html'],
+                       parse_mode='html')
+        return
+
+    await msg.edit(sub_result["msg"], parse_mode='html')
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_unsub(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    args = parse_command(event.raw_text)
+    user_id = event.chat_id
+
+    unsub_result = await inner.sub.unsubs(user_id, args, lang=lang)
+
+    if unsub_result is None:
+        buttons = await inner.utils.get_sub_choosing_buttons(user_id, lang=lang, page=1, callback='unsub',
+                                                             get_page_callback='get_unsub_page')
+        await event.respond(i18n[lang]['unsub_choose_sub_prompt_html'] if buttons else i18n[lang]['no_subscription'],
+                            buttons=buttons,
+                            parse_mode='html')
+        return
+
+    await event.respond(unsub_result['msg'], parse_mode='html')
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_unsub_all(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    unsub_all_result = await inner.sub.unsub_all(event.chat_id)
+    await event.respond(unsub_all_result['msg'] if unsub_all_result else i18n[lang]['no_subscription'],
+                        parse_mode='html')
+
+
+@command_gatekeeper(only_manager=False)
+async def cmd_list(event: Union[events.NewMessage.Event, Message], *_, lang: Optional[str] = None, **__):
+    subs = await inner.utils.list_sub(event.chat_id)
+    if not subs:
+        await event.respond(i18n[lang]['no_subscription'])
+        return
+
+    list_result = (
+            f'<b>{i18n[lang]["subscription_list"]}</b>\n'
+            + '\n'.join(f'<a href="{sub.feed.link}">{escape_html(sub.feed.title)}</a>' for sub in subs)
+    )
+
+    await event.respond(list_result, parse_mode='html')
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_unsub(event: events.CallbackQuery.Event, *_, lang: Optional[str] = None, **__):
+    # callback data = unsub_{sub_id}|{page}
+    sub_id, page = parse_callback_data_with_page(event.data)
+    unsub_d = await inner.sub.unsub(event.chat_id, sub_id=sub_id)
+
+    msg = (
+            f'<b>{i18n[lang]["unsub_successful" if unsub_d["sub"] else "unsub_failed"]}</b>\n'
+            + (
+                f'<a href="{unsub_d["sub"].feed.link}">{escape_html(unsub_d["sub"].feed.title)}</a>' if unsub_d['sub']
+                else f'{escape_html(unsub_d["url"])} ({unsub_d["msg"]})</a>'
+            )
+    )
+
+    if unsub_d['sub']:  # successfully unsubed
+        await callback_get_unsub_page.__wrapped__(event, lang=lang, page=page)
+
+    # await event.edit(msg, parse_mode='html')
+    await event.respond(msg, parse_mode='html')  # make unsubscribing multiple subscriptions more efficiency
+
+
+@command_gatekeeper(only_manager=False)
+async def callback_get_unsub_page(event: events.CallbackQuery.Event,
+                                  *_,
+                                  page: Optional[int] = None,
+                                  lang: Optional[str] = None,
+                                  **__):  # callback data = get_unsub_page_{page_number}
+    page = page or int(event.data.decode().strip().split('_')[-1])
+    buttons = await inner.utils.get_sub_choosing_buttons(event.chat_id, page, callback='unsub',
+                                                         get_page_callback='get_unsub_page', lang=lang)
+    await event.edit(None if buttons else i18n[lang]['no_subscription'], buttons=buttons)
diff --git a/src/command/utils.py b/src/command/utils.py
new file mode 100644
index 0000000000..a595af2759
--- /dev/null
+++ b/src/command/utils.py
@@ -0,0 +1,457 @@
+from __future__ import annotations
+from typing import Union, Optional, AnyStr, Any
+from collections.abc import Callable
+
+import asyncio
+import re
+from functools import partial, wraps
+from telethon import events
+from telethon.tl import types
+from telethon.tl.patched import Message, MessageService
+from telethon.tl.functions.bots import SetBotCommandsRequest
+from telethon.tl.functions.channels import GetParticipantRequest
+from telethon.errors import FloodError, MessageNotModifiedError, UserNotParticipantError, QueryIdInvalidError, \
+    UserIsBlockedError, ChatWriteForbiddenError, UserIdInvalidError, ChannelPrivateError
+
+from src import env, log, db, locks
+from src.i18n import i18n
+
+logger = log.getLogger('RSStT.command')
+
+
+# ANONYMOUS_ADMIN = 1087968824  # no need for MTProto, user_id will be `None` for anonymous admins
+
+
+def parse_command(command: str) -> list[AnyStr]:
+    return re.split(r'\s+', command.strip())
+
+
+def parse_callback_data_with_page(callback_data: bytes) -> tuple[int, int]:
+    """
+    callback data = command_{id}[|{page}]
+
+    :param callback_data: callback data
+    :return: id, page
+    """
+    callback_data = callback_data.decode().strip()
+    id_and_page = callback_data.split('|')
+    _id = int(id_and_page[0].split('_')[-1])
+    page = int(id_and_page[1]) if len(id_and_page) > 1 else 1
+    return _id, page
+
+
+def parse_sub_customization_callback_data(callback_data: bytes) \
+        -> tuple[Optional[int], Optional[str], Optional[Union[int, str]], int]:
+    """
+    callback data = command[_{id}[_{action}[_{param}]]][|{page_number}]
+
+    :param callback_data: callback data
+    :return: id, action, param
+    """
+    callback_data = callback_data.decode().strip()
+    args = callback_data.split('|')
+    page = int(args[1]) if len(args) > 1 else 1
+    args = args[0].split('_')
+
+    _id: Optional[int] = int(args[1]) if len(args) > 1 else None
+    action: Optional[str] = args[2] if len(args) > 2 else None
+    param: Optional[Union[int, str]] = args[3] if len(args) > 3 else None
+    if param and param.lstrip('-').isdecimal():
+        param = int(param)
+
+    return _id, action, param, page
+
+
+async def respond_or_answer(event: Union[events.NewMessage.Event, events.CallbackQuery.Event, Message], msg: str,
+                            alert: bool = True, cache_time: int = 120, *args, **kwargs):
+    """
+    Respond to a ``NewMessage`` event, or answer to an unanswered ``CallbackQuery`` event.
+
+    :param event: a telethon Event object, NewMessage or CallbackQuery
+    :param msg: the message to send
+    :param alert: alert or not? (only for CallbackQuery)
+    :param cache_time: cache the answer for how many seconds on the server side? (only for CallbackQuery)
+    :param args: additional params (only for NewMessage)
+    :param kwargs: additional params (only for NewMessage)
+    """
+    try:
+        # noinspection PyProtectedMember
+        if isinstance(event, events.CallbackQuery.Event) and not event._answered:
+            # answering callback query is of a tolerant rate limit, no lock needed
+            try:
+                await event.answer(msg, alert=alert, cache_time=cache_time)
+                return  # return if answering successfully
+            except QueryIdInvalidError:  # callback query expired
+                pass  # respond instead
+
+        async with await locks.user_flood_rwlock(event.chat_id).gen_rlock():
+            await event.respond(msg, *args, **kwargs)
+    except (UserIsBlockedError, UserIdInvalidError, ChatWriteForbiddenError, ChannelPrivateError):
+        pass  # silently ignore
+
+
+def command_gatekeeper(func: Optional[Callable] = None,
+                       *,
+                       only_manager: bool = False,
+                       only_in_private_chat: bool = False,
+                       ignore_tg_lang: bool = False,
+                       timeout: int = 60):
+    if func is None:
+        return partial(command_gatekeeper,
+                       only_manager=only_manager,
+                       only_in_private_chat=only_in_private_chat,
+                       ignore_tg_lang=ignore_tg_lang,
+                       timeout=timeout)
+
+    @wraps(func)
+    async def wrapper(event: Union[events.NewMessage.Event, Message,
+                                   events.CallbackQuery.Event,
+                                   events.ChatAction.Event],
+                      # Note: `events.ChatAction.Event` only have ChatGetter, do not have SenderGetter like others
+                      *args, **kwargs):
+        # placeholders
+        lang = None
+        command: Optional[str] = None
+        sender: Optional[Union[types.User, types.Channel]] = None
+        sender_fullname: Optional[str] = None
+        chat_title: Optional[str] = None
+        participant_type: Optional[str] = None
+        sender_id: Optional[int] = None
+
+        chat_id = event.chat_id
+        flood_rwlock = locks.user_flood_rwlock(chat_id)
+        pending_callbacks = locks.user_pending_callbacks(chat_id)
+        is_callback = isinstance(event, events.CallbackQuery.Event)
+        is_chat_action = isinstance(event, events.ChatAction.Event)
+
+        def describe_user():
+            chat_info = None
+            if (chat_title or chat_id) and chat_id != sender_id:
+                chat_info = f'{chat_title or chat_id}' + (f' ({chat_id})' if chat_title and chat_id else '')
+            return f'{sender_fullname} ({sender_id}' \
+                   + (f', {participant_type}' if participant_type and chat_info else '') \
+                   + ')' \
+                   + (f' in {chat_info}' if chat_info else '')
+
+        async def execute():
+            callback_msg_id = event.message_id if is_callback else None
+            # skip if already executing a callback for this msg
+            if callback_msg_id and callback_msg_id in pending_callbacks:
+                logger.info(f'Skipped {describe_user()} to use {command}: already executing a callback for this msg')
+                await respond_or_answer(event, i18n[lang]['callback_already_running_prompt'], cache_time=0)
+                raise events.StopPropagation
+
+            if callback_msg_id:
+                pending_callbacks.add(callback_msg_id)
+            try:
+                if lang_in_db is None:
+                    await db.User.get_or_create(id=chat_id, lang='null')  # create the user if it doesn't exist
+                logger.info(f'Allow {describe_user()} to use {command}')
+                async with await flood_rwlock.gen_rlock():
+                    await asyncio.wait_for(func(event, *args, lang=lang, **kwargs), timeout=timeout)
+            except asyncio.TimeoutError as _e:
+                logger.error(f'Cancel {command} for {describe_user()} due to timeout ({timeout}s)', exc_info=_e)
+                await respond_or_answer(event, 'ERROR: ' + i18n[lang]['operation_timeout_error'])
+            finally:
+                if callback_msg_id:
+                    try:
+                        pending_callbacks.remove(callback_msg_id)
+                    except KeyError:
+                        pass
+
+        try:
+            command = (event.raw_text
+                       if hasattr(event, 'raw_text') and event.raw_text else
+                       f'(Callback){event.data.decode()}'
+                       if is_callback else
+                       f'(ChatAction, {event.action_message and event.action_message.action.__class__.__name__})'
+                       if is_chat_action else
+                       '(no command, other message)')
+            command_header = parse_command(command)[0]
+            if command_header.startswith('/') and '@' in command_header:
+                mention = command_header.split('@')[-1]
+                if mention != env.bot_peer.username:
+                    raise events.StopPropagation  # none of my business!
+
+            if is_chat_action and event.action_message:  # service message
+                action_message: MessageService = event.action_message
+                sender_id = action_message.sender_id
+                sender = await action_message.get_sender()
+            elif not is_chat_action:  # message or callback
+                sender_id = event.sender_id  # `None` if the sender is an anonymous admin in a group
+                sender = await event.get_sender()  # ditto
+
+            sender_fullname = (
+                sender.title
+                if isinstance(sender, types.Channel) else
+                (sender.first_name + (f' {sender.last_name}' if sender.last_name else ''))
+                if sender is not None else
+                '__anonymous_admin__'
+                if not is_chat_action else
+                '__chat_action__'
+            )
+
+            # get the user's lang
+            lang_in_db = await db.User.get_or_none(id=chat_id).values_list('lang', flat=True)
+            lang = lang_in_db if lang_in_db != 'null' else None
+            if not lang and not ignore_tg_lang:
+                lang = sender.lang_code if hasattr(sender, 'lang_code') else None
+                if not lang and sender_id != chat_id:
+                    lang = db.User.get_or_none(id=sender_id).values_list('lang', flat=True)
+
+            if (only_manager or not env.MULTIUSER) and sender_id != env.MANAGER:
+                await respond_or_answer(event, i18n[lang]['permission_denied_not_bot_manager'])
+                logger.warning(f'Refused {describe_user()} to use {command} '
+                               f'because the command can only be used by a bot manager')
+                raise events.StopPropagation
+
+            if (
+                    event.is_private or  # deal with commands in private chats
+                    (
+                            (event.is_channel  # deal with commands in channels
+                             # a supergroup is also a channel, but we only expect a "real" channel here
+                             and not event.is_group)
+                            # if receiving a callback, we must verify that the sender is an admin. jump below
+                            and not is_callback
+                    )
+                    and not only_manager and not only_in_private_chat
+            ):  # we can deal with private chats and channels in the same way
+                await execute()
+                raise events.StopPropagation
+
+            if (
+                    (
+                            event.is_group or  # deal with commands in groups
+                            (event.is_channel and is_callback)  # deal with callback in channels
+                    )
+                    and not only_manager
+            ):  # receiving a command in a group, or, a callback in a channel
+                if isinstance(sender, types.Channel):
+                    raise events.StopPropagation  # channel messages are none of my business
+
+                # supergroup is a special form of channel
+                input_chat: Optional[Union[types.InputChannel,
+                                           types.InputPeerChannel,
+                                           types.InputPeerChat]] = await event.get_input_chat()
+                chat: Optional[Union[types.Chat, types.Channel]] = await event.get_chat()
+                chat_title = chat and chat.title
+
+                if only_in_private_chat:
+                    await respond_or_answer(event, i18n[lang]['permission_denied_not_in_private_chat'])
+                    logger.warning(f'Refused {describe_user()} to use {command} '
+                                   f'because the command can only be used in a private chat')
+                    raise events.StopPropagation
+
+                if isinstance(input_chat, types.InputPeerChat):
+                    # oops, the group hasn't been migrated to a supergroup. a migration is needed
+                    await event.respond('\n\n'.join(i18n.get_all_l10n_string('group_upgrade_needed_prompt')))
+                    logger.warning(f'Refused {describe_user()} to use {command} '
+                                   f'because a group migration to supergroup is needed')
+                    raise events.StopPropagation
+
+                # check if self is in the group/chanel and if is an admin
+                self_is_admin = True  # bypass check if the event is a callback query, set to True for convenience
+                if is_callback:
+                    try:
+                        self_participant: types.channels.ChannelParticipant = await env.bot(
+                            GetParticipantRequest(input_chat, env.bot_input_peer))
+                        self_is_admin = isinstance(self_participant.participant,
+                                                   (types.ChannelParticipantAdmin, types.ChannelParticipantCreator))
+                    except UserNotParticipantError:  # I am not a participant of the group/channel, none of my business!
+                        await respond_or_answer(event, i18n[lang]['permission_denied_bot_not_member'], cache_time=15)
+                        raise events.StopPropagation
+
+                # user permission check
+                if is_chat_action:
+                    is_admin = True
+                    participant_type = 'ChatAction, bypassing admin check'
+                elif sender_id is not None:  # a "real" user triggering the command
+                    input_sender: types.InputPeerUser = await event.get_input_sender()
+                    try:
+                        participant: types.channels.ChannelParticipant = await env.bot(
+                            GetParticipantRequest(input_chat, input_sender))
+                    except UserNotParticipantError:
+                        await respond_or_answer(event,
+                                                i18n[lang]['permission_denied_not_member'] if self_is_admin else
+                                                i18n[lang]['promote_to_admin_prompt'],
+                                                cache_time=15)
+                        logger.warning(f'Refused Refused {describe_user()} to use {command} '
+                                       f'because they is not a participant')
+                        raise events.StopPropagation
+                    is_admin = isinstance(participant.participant,
+                                          (types.ChannelParticipantAdmin, types.ChannelParticipantCreator))
+                    participant_type = type(participant.participant).__name__
+                else:  # an anonymous admin
+                    is_admin = True
+                    participant_type = 'AnonymousAdmin'
+
+                if not is_admin:
+                    await respond_or_answer(event, i18n[lang]['permission_denied_not_chat_admin'], cache_time=15)
+                    logger.warning(
+                        f'Refused {describe_user()} to use {command}')
+                    raise events.StopPropagation
+
+                await execute()
+                raise events.StopPropagation
+
+        except events.StopPropagation as e:
+            raise e
+        except Exception as e:
+            logger.error(
+                f'Uncaught error occurred when {sender_fullname} '
+                + f'({sender_id}'
+                + (f', {participant_type}' if participant_type else '')
+                + f') '
+                + f'attempting to use {command}'
+                + (f' in {chat_title} ({chat_id})' if chat_id != sender_id else ''),
+                exc_info=e
+            )
+            try:
+                if isinstance(e, FloodError):
+                    # blocking other commands to be executed and messages to be sent
+                    flood_wlock = await flood_rwlock.gen_wlock()
+                    if hasattr(e, 'seconds') \
+                            and e.seconds is not None \
+                            and not flood_rwlock.v_write_count:  # only lock once
+                        async with flood_wlock:
+                            await asyncio.sleep(e.seconds + 1)
+                    await respond_or_answer(event, 'ERROR: ' + i18n[lang]['flood_wait_prompt'])
+                    await env.bot(e.request)  # resend
+                # usually occurred because the user hits the same button during auto flood wait
+                elif isinstance(e, MessageNotModifiedError):
+                    await respond_or_answer(event, 'ERROR: ' + i18n[lang]['edit_conflict_prompt'])
+                else:
+                    await respond_or_answer(event, 'ERROR: ' + i18n[lang]['uncaught_internal_error'])
+            except (FloodError, MessageNotModifiedError):
+                pass  # we can do nothing but be a pessimism to drop it
+            except Exception as e:
+                logger.error('Uncaught error occurred when dealing with an uncaught error', exc_info=e)
+            finally:
+                raise events.StopPropagation
+
+    return wrapper
+
+
+def escape_html(raw: Any) -> str:
+    raw = str(raw)
+    return raw.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+
+
+class NewFileMessage(events.NewMessage):
+    def __init__(self, chats=None, *, blacklist_chats=False, func=None, incoming=None, outgoing=None, from_users=None,
+                 forwards=None, pattern=None, filename_pattern: str = None):
+        self.filename_pattern = re.compile(filename_pattern).match
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=func, incoming=incoming, outgoing=outgoing,
+                         from_users=from_users, forwards=forwards, pattern=pattern)
+
+    def filter(self, event: Union[events.NewMessage.Event, Message]):
+        document: types.Document = event.message.document
+        if not document:
+            return
+        if self.filename_pattern:
+            filename = None
+            for attr in document.attributes:
+                if isinstance(attr, types.DocumentAttributeFilename):
+                    filename = attr.file_name
+                    break
+            if not self.filename_pattern(filename or ''):
+                return
+        return super().filter(event)
+
+
+class ReplyMessage(events.NewMessage):
+    def __init__(self, chats=None, *, blacklist_chats=False, incoming=None, outgoing=None, from_users=None,
+                 forwards=None, pattern=None, reply_to_peer_id: int = None):
+        self.reply_to_peer_id = reply_to_peer_id or env.bot_id
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=self.__reply_verify, incoming=incoming,
+                         outgoing=outgoing, from_users=from_users, forwards=forwards, pattern=pattern)
+
+    async def __reply_verify(self, event: Union[events.NewMessage.Event, Message]):
+        if event.is_reply:
+            reply_to_msg: Optional[Message] = await event.get_reply_message()
+            if reply_to_msg is not None and self.reply_to_peer_id == reply_to_msg.sender_id:
+                return True
+        return False
+
+
+class PrivateMessage(events.NewMessage):
+    def __init__(self, chats=None, *, blacklist_chats=False, incoming=None, outgoing=None, from_users=None,
+                 forwards=None, pattern=None):
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=self.__in_private_chat, incoming=incoming,
+                         outgoing=outgoing, from_users=from_users, forwards=forwards, pattern=pattern)
+
+    @staticmethod
+    def __in_private_chat(event: Union[events.NewMessage.Event, Message]):
+        return event.is_private
+
+
+class AddedToGroupAction(events.ChatAction):
+    """Chat actions that are triggered when the bot has been added to a group."""
+
+    def __init__(self, chats=None, *, blacklist_chats=False):
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=self.__added_to_group)
+
+    @staticmethod
+    def __added_to_group(event: events.ChatAction.Event):
+        if not event.is_group:
+            return False
+        if event.created:
+            return True  # group created or migrated
+        if event.user_added or isinstance(event.action_message.action, types.MessageActionChatAddUser):
+            return env.bot_id in event.user_ids  # added to a group
+        return False
+
+
+class GroupMigratedAction(events.ChatAction):
+    """Chat actions that are triggered when a group has been migrated to a supergroup."""
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if (isinstance(update, (
+                types.UpdateNewMessage, types.UpdateNewChannelMessage))
+                and isinstance(update.message, types.MessageService)):
+            msg = update.message
+            action = update.message.action
+            if isinstance(action, types.MessageActionChannelMigrateFrom):
+                return cls.Event(msg)
+
+
+def get_commands_list(lang: Optional[str] = None, manager: bool = False) -> list[types.BotCommand]:
+    commands = [
+        types.BotCommand(command="sub", description=i18n[lang]['cmd_description_sub']),
+        types.BotCommand(command="unsub", description=i18n[lang]['cmd_description_unsub']),
+        types.BotCommand(command="unsub_all", description=i18n[lang]['cmd_description_unsub_all']),
+        types.BotCommand(command="list", description=i18n[lang]['cmd_description_list']),
+        types.BotCommand(command="set", description=i18n[lang]['cmd_description_set']),
+        types.BotCommand(command="import", description=i18n[lang]['cmd_description_import']),
+        types.BotCommand(command="export", description=i18n[lang]['cmd_description_export']),
+        types.BotCommand(command="activate_subs", description=i18n[lang]['cmd_description_activate_subs']),
+        types.BotCommand(command="deactivate_subs", description=i18n[lang]['cmd_description_deactivate_subs']),
+        types.BotCommand(command="version", description=i18n[lang]['cmd_description_version']),
+        types.BotCommand(command="lang", description=i18n[lang]['cmd_description_lang']),
+        types.BotCommand(command="help", description=i18n[lang]['cmd_description_help']),
+    ]
+
+    if manager:
+        commands.extend(
+            (
+                types.BotCommand(command="test", description=i18n[lang]['cmd_description_test']),
+                types.BotCommand(command="set_option", description=i18n[lang]['cmd_description_set_option']),
+            )
+        )
+
+    return commands
+
+
+async def set_bot_commands(scope: Union[types.BotCommandScopeDefault,
+                                        types.BotCommandScopePeer,
+                                        types.BotCommandScopePeerAdmins,
+                                        types.BotCommandScopeUsers,
+                                        types.BotCommandScopeChats,
+                                        types.BotCommandScopePeerUser,
+                                        types.BotCommandScopeChatAdmins],
+                           lang_code: str,
+                           commands: list[types.BotCommand]):
+    await env.bot(
+        SetBotCommandsRequest(scope=scope, lang_code=lang_code, commands=commands)
+    )
diff --git a/src/compat.py b/src/compat.py
new file mode 100644
index 0000000000..81411a473f
--- /dev/null
+++ b/src/compat.py
@@ -0,0 +1,83 @@
+"""Containing something make the bot compatible with Python 3.7 ~ 3.10"""
+
+import sys
+
+_version_info = sys.version_info
+if not (_version_info[0] == 3 and _version_info[1] >= 7):
+    raise RuntimeError("This bot requires Python 3.7 or later")
+
+import ssl
+from contextlib import AbstractContextManager, AbstractAsyncContextManager
+from typing import Any
+
+# add a false `Final` for Python 3.7
+try:
+    from typing import Final
+except ImportError:
+    Final = Any
+
+# backport `contextlib.nullcontext` for Python 3.7 ~ 3.9
+if _version_info[1] >= 10:
+    # noinspection PyUnresolvedReferences
+    from contextlib import nullcontext
+else:
+    # noinspection SpellCheckingInspection
+    class nullcontext(AbstractContextManager, AbstractAsyncContextManager):
+        """Backported `contextlib.nullcontext` from Python 3.10"""
+
+        def __init__(self, enter_result=None):
+            self.enter_result = enter_result
+
+        def __enter__(self):
+            return self.enter_result
+
+        def __exit__(self, *excinfo):
+            pass
+
+        async def __aenter__(self):
+            return self.enter_result
+
+        async def __aexit__(self, *excinfo):
+            pass
+
+# default cipher list in Python 3.9
+_ciphers_py39 = (
+    'TLS_AES_256_GCM_SHA384:'
+    'TLS_CHACHA20_POLY1305_SHA256:'
+    'TLS_AES_128_GCM_SHA256:'
+    'ECDHE-ECDSA-AES256-GCM-SHA384:'
+    'ECDHE-RSA-AES256-GCM-SHA384:'
+    'ECDHE-ECDSA-AES128-GCM-SHA256:'
+    'ECDHE-RSA-AES128-GCM-SHA256:'
+    'ECDHE-ECDSA-CHACHA20-POLY1305:'
+    'ECDHE-RSA-CHACHA20-POLY1305:'
+    'ECDHE-ECDSA-AES256-SHA384:'
+    'ECDHE-RSA-AES256-SHA384:'
+    'ECDHE-ECDSA-AES128-SHA256:'
+    'ECDHE-RSA-AES128-SHA256:'
+    'DHE-RSA-AES256-GCM-SHA384:'
+    'DHE-RSA-AES128-GCM-SHA256:'
+    'DHE-RSA-AES256-SHA256:'
+    'DHE-RSA-AES128-SHA256:'
+    'DHE-RSA-CHACHA20-POLY1305:'
+    'ECDHE-ECDSA-AES256-SHA:'
+    'ECDHE-RSA-AES256-SHA:'
+    'DHE-RSA-AES256-SHA:'
+    'ECDHE-ECDSA-AES128-SHA:'
+    'ECDHE-RSA-AES128-SHA:'
+    'DHE-RSA-AES128-SHA:'
+    'AES256-GCM-SHA384:'
+    'AES128-GCM-SHA256:'
+    'AES256-SHA256:'
+    'AES128-SHA256:'
+    'AES256-SHA:'
+    'AES128-SHA'
+)
+
+
+def ssl_create_default_context():
+    """`ssl.create_default_context`"""
+    context = ssl.create_default_context()
+    if _version_info[1] >= 10:  # However, TLSv1.1 still not enabled
+        context.set_ciphers(_ciphers_py39)
+    return context
diff --git a/src/db.py b/src/db.py
deleted file mode 100644
index 36fe08852d..0000000000
--- a/src/db.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import sqlite3
-import redis
-
-from src import log, env
-
-logger = log.getLogger('RSStT.db')
-
-if env.REDIS_HOST or env.REDIS_PORT or env.REDIS_USER or env.REDIS_PASSWORD or env.REDIS_NUM:
-    #  REDIS
-    class DB:
-        _pool = redis.ConnectionPool(host=env.REDIS_HOST,
-                                     port=6379 if not env.REDIS_PORT else env.REDIS_PORT,
-                                     username=env.REDIS_USER,
-                                     password=env.REDIS_PASSWORD,
-                                     db=0 if not env.REDIS_NUM else env.REDIS_NUM,
-                                     socket_connect_timeout=1.5,
-                                     socket_timeout=1.5,
-                                     retry_on_timeout=True,
-                                     decode_responses=True)
-
-        def __init__(self):
-            self.feed_dict = {}
-            try:
-                self._rds = redis.Redis(connection_pool=DB._pool)
-                self.load_all()
-            except Exception as e:
-                logger.critical('Cannot connect to redis!', exc_info=e)
-                exit(1)
-
-        def load_all(self):
-            if self.feed_dict:
-                self.feed_dict.clear()
-            keys = self._rds.keys()
-            for key in keys:
-                link, last = self._rds.hmget(key, 'link', 'last')
-                self.feed_dict[key] = (link, last)
-
-        def read(self, name):
-            return self.feed_dict.get(name)
-
-        def read_all(self):
-            return self.feed_dict
-
-        def write(self, name, link, last, update=False):
-            self._rds.hmset(name, {'link': link, 'last': last})
-            self.feed_dict[name] = (link, last)
-
-        def delete(self, name):
-            self._rds.delete(name)
-            del self.feed_dict[name]
-
-
-else:
-    # SQLITE
-    class DB:
-        def __init__(self):
-            self._conn = None
-            self.feed_dict = {}
-            self._init()
-            self.load_all()
-
-        def _init(self):
-            try:
-                self._conn = sqlite3.connect('config/rss.db', check_same_thread=False)
-                c = self._conn.cursor()
-                c.execute('''CREATE TABLE rss (name text, link text, last text)''')
-            except sqlite3.OperationalError:
-                pass
-
-        def load_all(self):
-            c = self._conn.cursor()
-            c.execute('SELECT * FROM rss')
-            rows = c.fetchall()
-            if self.feed_dict:
-                self.feed_dict.clear()
-            for row in rows:
-                self.feed_dict[row[0]] = (row[1], row[2])
-            return rows
-
-        def read(self, name):
-            return self.feed_dict.get(name)
-
-        def read_all(self):
-            return self.feed_dict
-
-        def write(self, name, link, last, update=False):
-            c = self._conn.cursor()
-            p = [last, name]
-            q = [name, link, last]
-            if update:
-                c.execute('''UPDATE rss SET last = ? WHERE name = ?;''', p)
-            else:
-                c.execute('''INSERT INTO rss('name','link','last') VALUES(?,?,?)''', q)
-            self._conn.commit()
-            self.feed_dict[name] = (link, last)
-
-        def delete(self, name):
-            c = self._conn.cursor()
-            q = (name,)
-            c.execute("DELETE FROM rss WHERE name = ?", q)
-            self._conn.commit()
-            del self.feed_dict[name]
-
-db = DB()
diff --git a/src/db/__init__.py b/src/db/__init__.py
new file mode 100644
index 0000000000..aeaca116fc
--- /dev/null
+++ b/src/db/__init__.py
@@ -0,0 +1,35 @@
+from tortoise import Tortoise
+from aerich import Command
+
+from . import config, models
+from src import env, log
+from . import effective_utils
+
+logger = log.getLogger('RSStT.db')
+
+User = models.User
+Feed = models.Feed
+Sub = models.Sub
+Option = models.Option
+EffectiveOptions = effective_utils.EffectiveOptions
+EffectiveTasks = effective_utils.EffectiveTasks
+
+
+async def init():
+    if env.DATABASE_URL.startswith('sqlite'):
+        aerich_command = Command(tortoise_config=config.TORTOISE_ORM, location='src/db/migrations_sqlite')
+    elif env.DATABASE_URL.startswith('postgres'):
+        aerich_command = Command(tortoise_config=config.TORTOISE_ORM, location='src/db/migrations_pgsql')
+    else:
+        aerich_command = None
+        logger.critical('INVALID DB SCHEME! ONLY "sqlite" AND "postgres" ARE SUPPORTED!')
+        exit(1)
+    await aerich_command.init()
+    await aerich_command.upgrade()
+    # await Tortoise.init(config=config.TORTOISE_ORM)
+    await effective_utils.init()
+    logger.info('Successfully connected to the DB')
+
+
+async def close():
+    await Tortoise.close_connections()
diff --git a/src/db/config.py b/src/db/config.py
new file mode 100644
index 0000000000..88476b46df
--- /dev/null
+++ b/src/db/config.py
@@ -0,0 +1,13 @@
+from src import env
+
+TORTOISE_ORM = {
+    "connections": {
+        "default": env.DATABASE_URL
+    },
+    "apps": {
+        "models": {
+            "models": ["aerich.models", "src.db.models"],
+            "default_connection": "default",
+        },
+    },
+}
diff --git a/src/db/effective_utils.py b/src/db/effective_utils.py
new file mode 100644
index 0000000000..d971c8ffc1
--- /dev/null
+++ b/src/db/effective_utils.py
@@ -0,0 +1,247 @@
+from __future__ import annotations
+from typing import Optional, Any, NoReturn, Union
+from collections.abc import Callable
+from src.compat import Final
+
+from math import ceil
+
+from src.db import models
+
+
+class __EffectiveOptions:
+    """
+    EffectiveOptions singleton class.
+
+    Implement a write-through cache that caches all options to reduce db load.
+    """
+    __singleton: Optional["__EffectiveOptions"] = None
+    __initialized: bool = False
+
+    def __new__(cls, *args, **kwargs):
+        if not cls.__singleton:
+            cls.__singleton = super().__new__(cls)
+        return cls.__singleton
+
+    def __init__(self):
+        if self.__initialized:
+            return
+        self.__initialized = True
+
+        self.__options: dict[str, Union[str, int]] = {}
+        self.__cached = False
+        self.__default_options: dict[str, Union[str, int]] = {
+            "default_interval": 10,
+            "minimal_interval": 5,
+        }
+
+    @property
+    def options(self) -> dict[str, Union[str, int]]:
+        return self.__options.copy()
+
+    @property
+    def default_options(self) -> dict[str, Union[str, int]]:
+        return self.__default_options.copy()
+
+    @property
+    def default_interval(self) -> int:
+        return self.get('default_interval')
+
+    @property
+    def minimal_interval(self) -> int:
+        return self.get("minimal_interval")
+
+    def validate(self, key: str, value: Union[int, str], ignore_type_error: bool = False) -> Union[int, str]:
+        if len(key) > 255:
+            raise KeyError("Option key must be 255 characters or less")
+
+        value_type = type(self.__default_options[key])
+        if value_type is str:
+            return str(value)
+
+        if value_type is int and type(value) is str:
+            if value.lstrip('-').isdecimal():
+                return int(value)
+
+            if ignore_type_error:
+                return self.__default_options[key]
+            raise ValueError("Option value must be an integer")
+
+        return value
+
+    def get(self, key: str) -> Union[str, int]:
+        """
+        Get the value of an Option.
+
+        :param key: option key
+        :return: option value
+        """
+        if not self.__cached:
+            raise RuntimeError("Options cache not initialized")
+        return self.__options[key]
+
+    async def set(self, key: str, value: Union[int, str]) -> NoReturn:
+        """
+        Set the value of an Option. (write-through to the DB)
+
+        :param key: option key
+        :param value: option value
+        """
+        value = self.validate(key, value)
+        await models.Option.update_or_create(defaults={'value': str(value)}, key=key)
+        self.__options[key] = value
+
+    async def cache(self) -> NoReturn:
+        """
+        Cache all options from the DB.
+        """
+        options = await models.Option.all()
+        for option in options:
+            if option.key not in self.__default_options:  # invalid option
+                continue
+            self.__options[option.key] = self.validate(option.key, option.value, ignore_type_error=True)
+
+        for key, value in self.__default_options.items():
+            if key in self.__options:
+                continue
+            self.__options[key] = value
+            # await models.Option.create(key=key, value=value)  # init option
+
+        self.__cached = True
+
+
+EffectiveOptions = __EffectiveOptions()
+
+
+class EffectiveTasks:
+    """
+    EffectiveTasks class.
+
+    A task dispatcher.
+    """
+    __task_buckets: dict[int, "EffectiveTasks"] = {}  # key: interval, value: EffectiveTasks
+    __all_tasks: dict[int, int] = {}  # key: id, value: interval
+
+    def __init__(self, interval: int) -> NoReturn:
+        self.interval: Final = interval
+        self.__all_feeds = set()
+        self.__pending_feeds = set()
+        # self.__checked_feeds = set()
+        self.__run_count = 0
+
+    @staticmethod
+    def __ignore_key_error(func: Callable, *args, **kwargs) -> Optional[Any]:
+        try:
+            return func(*args, **kwargs)
+        except KeyError:
+            return None
+
+    @classmethod
+    async def init(cls, flush: bool = False) -> NoReturn:
+        """
+        Load a feeds from the DB and initialize tasks.
+
+        :param flush: if already initialized, re-initialize?
+        """
+        if not cls.__task_buckets or flush:
+            cls.__all_tasks = {}
+            cls.__task_buckets = {}
+            feeds = await models.Feed.filter(state=1).values('id', 'interval')
+            default_interval = EffectiveOptions.default_interval
+            for feed in feeds:
+                cls.update(feed_id=feed['id'], interval=feed['interval'] or default_interval)
+
+    def __update(self, feed_id: int):
+        self.__all_feeds.add(feed_id)
+        self.__pending_feeds.add(feed_id)
+
+    @classmethod
+    def update(cls, feed_id: int, interval: int = None) -> NoReturn:
+        """
+        Update or add a task.
+
+        :param feed_id: the id of the feed in the task
+        :param interval: the interval of the task
+        """
+        interval = interval or EffectiveOptions.default_interval
+        if feed_id in cls.__all_tasks:  # if already have a task
+            if cls.__all_tasks[feed_id] == interval:  # no need to update
+                return
+            cls.delete(feed_id, _preserve_in_all_tasks=True)  # delete the old one
+
+        if interval not in cls.__task_buckets:  # if lack of bucket
+            cls.__task_buckets[interval] = cls(interval)  # create one
+
+        cls.__all_tasks[feed_id] = interval  # log the new task
+        cls.__task_buckets[interval].__update(feed_id)  # update task
+
+    def __delete(self, feed_id: int) -> NoReturn:
+        self.__ignore_key_error(self.__all_feeds.remove, feed_id)
+        self.__ignore_key_error(self.__pending_feeds.remove, feed_id)
+
+    @classmethod
+    def delete(cls, feed_id: int, _preserve_in_all_tasks: bool = False) -> NoReturn:
+        """
+        Delete a task.
+
+        :param feed_id: the id of the feed in the task
+        :param _preserve_in_all_tasks: for internal use
+        """
+        try:
+            old_interval = cls.__all_tasks[feed_id]
+            cls.__task_buckets[old_interval].__delete(feed_id)
+
+            if not _preserve_in_all_tasks:
+                del cls.__all_tasks[feed_id]
+        except KeyError:
+            pass
+
+    @classmethod
+    def exist(cls, feed_id: int) -> bool:
+        """
+        Check if a task exists.
+
+        :param feed_id: the id of the feed in the task
+        :return `bool`: if the task exists
+        """
+        return feed_id in cls.__all_tasks
+
+    @classmethod
+    def get_interval(cls, feed_id: int) -> Optional[int]:
+        """
+        Get the interval of a task.
+
+        :param feed_id: the id of the feed in the task
+        :return `int`: the interval of the task, or `None` if task do not exist
+        """
+        return cls.__all_tasks[feed_id] if cls.exist(feed_id) else None
+
+    def __get_tasks(self) -> set[int]:
+        if len(self.__all_feeds) == 0:
+            return set()  # nothing to run
+        if self.__run_count == 0:
+            self.__pending_feeds.update(self.__all_feeds)
+
+        pop_count = ceil(len(self.__pending_feeds) / (self.interval - self.__run_count))
+        tasks_to_run = set(self.__pending_feeds.pop() for _ in range(pop_count) if self.__pending_feeds)
+        self.__run_count = self.__run_count + 1 if self.__run_count + 1 < self.interval else 0
+        return tasks_to_run
+
+    @classmethod
+    def get_tasks(cls) -> set[int]:
+        """
+        Get tasks to be run.
+
+        :return: a `set` contains the ids of feeds in tasks to be run
+        """
+        tasks_to_run = set()
+        for effective_tasks in cls.__task_buckets.values():
+            tasks = effective_tasks.__get_tasks()
+            if tasks:
+                tasks_to_run.update(tasks)
+
+        return tasks_to_run
+
+
+async def init():
+    await EffectiveOptions.cache()
+    await EffectiveTasks.init()
diff --git a/src/db/migrations_pgsql/models/0_20211117110249_init.sql b/src/db/migrations_pgsql/models/0_20211117110249_init.sql
new file mode 100644
index 0000000000..9fed5b6261
--- /dev/null
+++ b/src/db/migrations_pgsql/models/0_20211117110249_init.sql
@@ -0,0 +1,89 @@
+-- upgrade --
+CREATE TABLE IF NOT EXISTS "aerich" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "version" VARCHAR(255) NOT NULL,
+    "app" VARCHAR(20) NOT NULL,
+    "content" JSONB NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "feed" (
+    "created_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "state" SMALLINT NOT NULL  DEFAULT 1,
+    "link" VARCHAR(4096) NOT NULL UNIQUE,
+    "title" VARCHAR(1024) NOT NULL,
+    "interval" SMALLINT,
+    "entry_hashes" TEXT,
+    "etag" VARCHAR(128),
+    "error_count" SMALLINT NOT NULL  DEFAULT 0,
+    "next_check_time" TIMESTAMPTZ
+);
+COMMENT ON COLUMN "feed"."created_at" IS 'The time this row was created';
+COMMENT ON COLUMN "feed"."updated_at" IS 'The time this row was updated';
+COMMENT ON COLUMN "feed"."state" IS 'Feed state: 0=deactivated, 1=activated';
+COMMENT ON COLUMN "feed"."link" IS 'Feed link';
+COMMENT ON COLUMN "feed"."title" IS 'Feed title';
+COMMENT ON COLUMN "feed"."interval" IS 'Monitoring task interval. Should be the minimal interval of all subs to the feed,default interval will be applied if null';
+COMMENT ON COLUMN "feed"."entry_hashes" IS 'Hashes (CRC32) of entries';
+COMMENT ON COLUMN "feed"."etag" IS 'The etag of webpage, will be changed each time the feed is updated. Can be null because some websites do not support';
+COMMENT ON COLUMN "feed"."error_count" IS 'Error counts. If too many, deactivate the feed. +1 if an error occurs, reset to 0 if feed fetched successfully';
+COMMENT ON COLUMN "feed"."next_check_time" IS 'Next checking time. If too many errors occur, let us wait sometime';
+COMMENT ON TABLE "feed" IS 'Feed model.';
+CREATE TABLE IF NOT EXISTS "option" (
+    "created_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "key" VARCHAR(255) NOT NULL UNIQUE,
+    "value" TEXT
+);
+COMMENT ON COLUMN "option"."created_at" IS 'The time this row was created';
+COMMENT ON COLUMN "option"."updated_at" IS 'The time this row was updated';
+COMMENT ON TABLE "option" IS 'Option model.';
+CREATE TABLE IF NOT EXISTS "user" (
+    "created_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "id" BIGSERIAL NOT NULL PRIMARY KEY,
+    "state" SMALLINT NOT NULL  DEFAULT 0,
+    "lang" VARCHAR(16) NOT NULL  DEFAULT 'zh-Hans',
+    "admin" BIGINT
+);
+COMMENT ON COLUMN "user"."created_at" IS 'The time this row was created';
+COMMENT ON COLUMN "user"."updated_at" IS 'The time this row was updated';
+COMMENT ON COLUMN "user"."id" IS 'Telegram user id, 8Bytes';
+COMMENT ON COLUMN "user"."state" IS 'User state: -1=banned, 0=guest, 1=user, 50=channel, 51=group, 100=admin';
+COMMENT ON COLUMN "user"."lang" IS 'Preferred language, lang code';
+COMMENT ON COLUMN "user"."admin" IS 'One of the admins of the channel or group, can be null if this \"user\" is not a channel or a group';
+COMMENT ON TABLE "user" IS 'User model.';
+CREATE TABLE IF NOT EXISTS "sub" (
+    "created_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "state" SMALLINT NOT NULL  DEFAULT 1,
+    "tags" VARCHAR(255),
+    "interval" SMALLINT,
+    "notify" SMALLINT NOT NULL  DEFAULT 1,
+    "send_mode" SMALLINT NOT NULL  DEFAULT 0,
+    "length_limit" SMALLINT NOT NULL  DEFAULT 0,
+    "link_preview" SMALLINT NOT NULL  DEFAULT 0,
+    "display_author" SMALLINT NOT NULL  DEFAULT 0,
+    "display_via" SMALLINT NOT NULL  DEFAULT 0,
+    "display_title" SMALLINT NOT NULL  DEFAULT 0,
+    "style" SMALLINT NOT NULL  DEFAULT 0,
+    "feed_id" INT NOT NULL REFERENCES "feed" ("id") ON DELETE CASCADE,
+    "user_id" BIGINT NOT NULL REFERENCES "user" ("id") ON DELETE CASCADE,
+    CONSTRAINT "uid_sub_user_id_029239" UNIQUE ("user_id", "feed_id")
+);
+COMMENT ON COLUMN "sub"."created_at" IS 'The time this row was created';
+COMMENT ON COLUMN "sub"."updated_at" IS 'The time this row was updated';
+COMMENT ON COLUMN "sub"."state" IS 'Sub state: 0=deactivated, 1=activated';
+COMMENT ON COLUMN "sub"."tags" IS 'Tags of the sub';
+COMMENT ON COLUMN "sub"."interval" IS 'Interval of the sub monitor task, default interval will be applied if null';
+COMMENT ON COLUMN "sub"."notify" IS 'Enable notification or not? 0: disable, 1=enable';
+COMMENT ON COLUMN "sub"."send_mode" IS 'Send mode: -1=force link, 0=auto, 1=force Telegraph, 2=force message';
+COMMENT ON COLUMN "sub"."length_limit" IS 'Telegraph length limit, valid when send_mode==0. If exceed, send via Telegraph; If is 0, send via Telegraph when a post cannot be send in a single message';
+COMMENT ON COLUMN "sub"."link_preview" IS 'Enable link preview or not? 0=auto, 1=force enable';
+COMMENT ON COLUMN "sub"."display_author" IS 'Display author or not?-1=disable, 0=auto, 1=force display';
+COMMENT ON COLUMN "sub"."display_via" IS 'Display via or not?-2=completely disable, -1=disable but display link, 0=auto, 1=force display';
+COMMENT ON COLUMN "sub"."display_title" IS 'Display title or not?-1=disable, 0=auto, 1=force display';
+COMMENT ON COLUMN "sub"."style" IS 'Style of posts: 0=RSStT, 1=flowerss';
+COMMENT ON TABLE "sub" IS 'Sub model.';
diff --git a/src/db/migrations_pgsql/models/1_20211130051128_update.sql b/src/db/migrations_pgsql/models/1_20211130051128_update.sql
new file mode 100644
index 0000000000..be33fc9980
--- /dev/null
+++ b/src/db/migrations_pgsql/models/1_20211130051128_update.sql
@@ -0,0 +1,6 @@
+-- upgrade --
+ALTER TABLE "feed" ADD "last_modified" TIMESTAMPTZ;
+ALTER TABLE "sub" ADD "title" VARCHAR(1024);
+-- downgrade --
+ALTER TABLE "sub" DROP COLUMN "title";
+ALTER TABLE "feed" DROP COLUMN "last_modified";
diff --git a/src/db/migrations_sqlite/models/0_20211117110249_init.sql b/src/db/migrations_sqlite/models/0_20211117110249_init.sql
new file mode 100644
index 0000000000..32ac16a8e8
--- /dev/null
+++ b/src/db/migrations_sqlite/models/0_20211117110249_init.sql
@@ -0,0 +1,54 @@
+-- upgrade --
+CREATE TABLE IF NOT EXISTS "aerich" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "version" VARCHAR(255) NOT NULL,
+    "app" VARCHAR(20) NOT NULL,
+    "content" JSON NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "feed" (
+    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was created */,
+    "updated_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was updated */,
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "state" SMALLINT NOT NULL  DEFAULT 1 /* Feed state: 0=deactivated, 1=activated */,
+    "link" VARCHAR(4096) NOT NULL UNIQUE /* Feed link */,
+    "title" VARCHAR(1024) NOT NULL  /* Feed title */,
+    "interval" SMALLINT   /* Monitoring task interval. Should be the minimal interval of all subs to the feed,default interval will be applied if null */,
+    "entry_hashes" TEXT   /* Hashes (CRC32) of entries */,
+    "etag" VARCHAR(128)   /* The etag of webpage, will be changed each time the feed is updated. Can be null because some websites do not support */,
+    "error_count" SMALLINT NOT NULL  DEFAULT 0 /* Error counts. If too many, deactivate the feed. +1 if an error occurs, reset to 0 if feed fetched successfully */,
+    "next_check_time" TIMESTAMP   /* Next checking time. If too many errors occur, let us wait sometime */
+) /* Feed model. */;
+CREATE TABLE IF NOT EXISTS "option" (
+    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was created */,
+    "updated_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was updated */,
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "key" VARCHAR(255) NOT NULL UNIQUE,
+    "value" TEXT
+) /* Option model. */;
+CREATE TABLE IF NOT EXISTS "user" (
+    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was created */,
+    "updated_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was updated */,
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL /* Telegram user id, 8Bytes */,
+    "state" SMALLINT NOT NULL  DEFAULT 0 /* User state: -1=banned, 0=guest, 1=user, 50=channel, 51=group, 100=admin */,
+    "lang" VARCHAR(16) NOT NULL  DEFAULT 'zh-Hans' /* Preferred language, lang code */,
+    "admin" BIGINT   /* One of the admins of the channel or group, can be null if this "user" is not a channel or a group */
+) /* User model. */;
+CREATE TABLE IF NOT EXISTS "sub" (
+    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was created */,
+    "updated_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP /* The time this row was updated */,
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "state" SMALLINT NOT NULL  DEFAULT 1 /* Sub state: 0=deactivated, 1=activated */,
+    "tags" VARCHAR(255)   /* Tags of the sub */,
+    "interval" SMALLINT   /* Interval of the sub monitor task, default interval will be applied if null */,
+    "notify" SMALLINT NOT NULL  DEFAULT 1 /* Enable notification or not? 0: disable, 1=enable */,
+    "send_mode" SMALLINT NOT NULL  DEFAULT 0 /* Send mode: -1=force link, 0=auto, 1=force Telegraph, 2=force message */,
+    "length_limit" SMALLINT NOT NULL  DEFAULT 0 /* Telegraph length limit, valid when send_mode==0. If exceed, send via Telegraph; If is 0, send via Telegraph when a post cannot be send in a single message */,
+    "link_preview" SMALLINT NOT NULL  DEFAULT 0 /* Enable link preview or not? 0=auto, 1=force enable */,
+    "display_author" SMALLINT NOT NULL  DEFAULT 0 /* Display author or not?-1=disable, 0=auto, 1=force display */,
+    "display_via" SMALLINT NOT NULL  DEFAULT 0 /* Display via or not?-2=completely disable, -1=disable but display link, 0=auto, 1=force display */,
+    "display_title" SMALLINT NOT NULL  DEFAULT 0 /* Display title or not?-1=disable, 0=auto, 1=force display */,
+    "style" SMALLINT NOT NULL  DEFAULT 0 /* Style of posts: 0=RSStT, 1=flowerss */,
+    "feed_id" INT NOT NULL REFERENCES "feed" ("id") ON DELETE CASCADE,
+    "user_id" BIGINT NOT NULL REFERENCES "user" ("id") ON DELETE CASCADE,
+    CONSTRAINT "uid_sub_user_id_029239" UNIQUE ("user_id", "feed_id")
+) /* Sub model. */;
diff --git a/src/db/migrations_sqlite/models/1_20211130051128_update.sql b/src/db/migrations_sqlite/models/1_20211130051128_update.sql
new file mode 100644
index 0000000000..962e4a3a6b
--- /dev/null
+++ b/src/db/migrations_sqlite/models/1_20211130051128_update.sql
@@ -0,0 +1,6 @@
+-- upgrade --
+ALTER TABLE "feed" ADD "last_modified" TIMESTAMP   /* The last modified time of webpage.  */;
+ALTER TABLE "sub" ADD "title" VARCHAR(1024)   /* Sub title, overriding feed title if set */;
+-- downgrade --
+ALTER TABLE "feed" DROP COLUMN "last_modified";
+ALTER TABLE "sub" DROP COLUMN "title";
diff --git a/src/db/models.py b/src/db/models.py
new file mode 100644
index 0000000000..3fc621585c
--- /dev/null
+++ b/src/db/models.py
@@ -0,0 +1,138 @@
+"""
+RSStT db models
+"""
+
+from tortoise import fields
+from tortoise.models import Model
+
+
+class Base:
+    """
+    Model template.
+
+    Contains `created_at` and `updated_at`.
+    """
+    created_at = fields.DatetimeField(auto_now_add=True, description='The time this row was created')
+    updated_at = fields.DatetimeField(auto_now=True, description='The time this row was updated')
+
+
+class User(Model, Base):
+    """
+    User model.
+
+    Stores users, their info and their default feed options.
+    """
+    id = fields.BigIntField(pk=True, description='Telegram user id, 8Bytes')
+    state = fields.SmallIntField(default=0, description='User state: '
+                                                        '-1=banned, 0=guest, 1=user, 50=channel, 51=group, 100=admin')
+    lang = fields.CharField(default='zh-Hans', max_length=16, description='Preferred language, lang code')
+    admin = fields.BigIntField(null=True, description='One of the admins of the channel or group, '
+                                                      'can be null if this "user" is not a channel or a group')
+    subs: fields.ReverseRelation['Sub']
+
+    # default options of a user's feeds
+    # interval = fields.SmallIntField(null=True)
+    # notify = fields.SmallIntField(null=True)
+    # send_mode = fields.SmallIntField(null=True)
+    # length_limit = fields.SmallIntField(null=True)
+    # display_author = fields.SmallIntField(null=True)
+    # display_via = fields.SmallIntField(null=True)
+    # display_title = fields.SmallIntField(null=True)
+
+    class Meta:
+        table = 'user'
+
+    def __str__(self):
+        return self.id
+
+
+class Feed(Model, Base):
+    """
+    Feed model.
+
+    Stores feeds and their info.
+    """
+    id = fields.IntField(pk=True)
+    state = fields.SmallIntField(default=1, description='Feed state: '
+                                                        '0=deactivated, 1=activated')
+    link = fields.CharField(max_length=4096,  # hey, is there really any rss feed url > 4096B?
+                            unique=True,  # will also be indexed
+                            description='Feed link')
+    title = fields.CharField(max_length=1024, description='Feed title')
+    interval = fields.SmallIntField(null=True, description='Monitoring task interval. '
+                                                           'Should be the minimal interval of all subs to the feed,'
+                                                           'default interval will be applied if null')
+    entry_hashes = fields.JSONField(null=True, description='Hashes (CRC32) of entries')
+    etag = fields.CharField(max_length=128, null=True,
+                            description='The etag of webpage, will be changed each time the feed is updated. '
+                                        'Can be null because some websites do not support')
+    last_modified = fields.DatetimeField(null=True, description='The last modified time of webpage. ')
+    error_count = fields.SmallIntField(default=0,
+                                       description='Error counts. If too many, deactivate the feed. '
+                                                   '+1 if an error occurs, reset to 0 if feed fetched successfully')
+    next_check_time = fields.DatetimeField(null=True,
+                                           description='Next checking time. '
+                                                       'If too many errors occur, let us wait sometime')
+    subs: fields.ReverseRelation['Sub']
+
+    class Meta:
+        table = 'feed'
+
+    def __str__(self):
+        return self.link
+
+
+class Sub(Model, Base):
+    """
+    Sub model.
+
+    Stores subscriptions (who subscribed which feed) and their options, many to many relation.
+    """
+    id = fields.IntField(pk=True)
+    state = fields.SmallIntField(default=1, description='Sub state: '
+                                                        '0=deactivated, 1=activated')
+    user: fields.ForeignKeyRelation['User'] = \
+        fields.ForeignKeyField('models.User', related_name='subs', to_field='id', on_delete=fields.CASCADE)
+    feed: fields.ForeignKeyRelation['Feed'] = \
+        fields.ForeignKeyField('models.Feed', related_name='subs', to_field='id', on_delete=fields.CASCADE)
+    title = fields.CharField(max_length=1024, null=True, description='Sub title, overriding feed title if set')
+    tags = fields.CharField(max_length=255, null=True, description='Tags of the sub')
+    interval = fields.SmallIntField(null=True, description='Interval of the sub monitor task, '
+                                                           'default interval will be applied if null')
+    notify = fields.SmallIntField(default=1, description='Enable notification or not? '
+                                                         '0: disable, 1=enable')
+    send_mode = fields.SmallIntField(default=0, description='Send mode: '
+                                                            '-1=force link, 0=auto, 1=force Telegraph, 2=force message')
+    length_limit = fields.SmallIntField(default=0, description='Telegraph length limit, valid when send_mode==0. '
+                                                               'If exceed, send via Telegraph; '
+                                                               'If is 0, send via Telegraph '
+                                                               'when a post cannot be send in a single message')
+    link_preview = fields.SmallIntField(default=0, description='Enable link preview or not? '
+                                                               '0=auto, 1=force enable')
+    display_author = fields.SmallIntField(default=0, description='Display author or not?'
+                                                                 '-1=disable, 0=auto, 1=force display')
+    display_via = fields.SmallIntField(default=0, description='Display via or not?'
+                                                              '-2=completely disable, -1=disable but display link, '
+                                                              '0=auto, 1=force display')
+    display_title = fields.SmallIntField(default=0, description='Display title or not?'
+                                                                '-1=disable, 0=auto, 1=force display')
+    style = fields.SmallIntField(default=0, description='Style of posts: '
+                                                        '0=RSStT, 1=flowerss')
+
+    class Meta:
+        table = 'sub'
+        unique_together = ('user_id', 'feed_id')  # will also be indexed
+
+
+class Option(Model, Base):
+    """
+    Option model.
+
+    Stores options set by admins.
+    """
+    id = fields.IntField(pk=True)
+    key = fields.CharField(max_length=255, unique=True)  # will also be indexed
+    value = fields.TextField(null=True)
+
+    class Meta:
+        table = 'option'
diff --git a/src/env.py b/src/env.py
index 9892b7d1ed..b91e5f7846 100644
--- a/src/env.py
+++ b/src/env.py
@@ -1,14 +1,75 @@
+from __future__ import annotations
+from typing import Optional
+from src.compat import Final
+
+import asyncio
 import os
 import logging
+import re
 from telethon import TelegramClient
-from typing import Optional, Final
+from telethon.tl.types import User, InputPeerUser
 from python_socks import parse_proxy_url
 from dotenv import load_dotenv
 
+
+# ----- utils -----
+def __bool_parser(var: Optional[str], default_value: bool = False) -> bool:
+    if not var:
+        return default_value
+
+    if var.isdecimal() or var.lstrip('-').isdecimal():
+        return int(var) > 0
+
+    var = var.upper()
+    if var in ('FALSE', 'NONE', 'NULL', 'NO', 'NOT', 'DISABLE', 'DISABLED', 'INACTIVE', 'DEACTIVATED', 'OFF'):
+        return False
+    if var in ('TRUE', 'YES', 'OK', 'ENABLE', 'ENABLED', 'ACTIVE', 'ACTIVATED', 'ON'):
+        return True
+    return default_value
+
+
+def __list_parser(var: Optional[str]) -> list[str]:
+    if not var:
+        return []
+
+    var_t = re.split(r'[\s,;，；]+', var.strip())
+    return var_t
+
+
 # ----- load .env -----
 load_dotenv(override=True)
 
-# ----- base config -----
+# ----- get version -----
+# noinspection PyBroadException
+try:
+    with open('.version', 'r') as v:
+        _version = v.read().strip()
+except Exception:
+    _version = 'dirty'
+
+if _version == 'dirty':
+    from subprocess import Popen, PIPE, DEVNULL
+
+    # noinspection PyBroadException
+    try:
+        with Popen('git describe --tags', shell=True, stdout=PIPE, stderr=DEVNULL, bufsize=-1) as __:
+            __.wait(3)
+            _version = __.stdout.read().decode().strip()
+        with Popen('git branch --show-current', shell=True, stdout=PIPE, stderr=DEVNULL, bufsize=-1) as __:
+            __.wait(3)
+            __ = __.stdout.read().decode().strip()
+            if __:
+                _version += f'@{__}'
+    except Exception:
+        _version = 'dirty'
+
+if not _version or _version == '@':
+    _version = 'dirty'
+
+VERSION: Final = _version
+del _version
+
+# ----- basic config -----
 SAMPLE_APIS: Final = {
     # https://github.com/DrKLO/Telegram/blob/master/TMessagesProj/src/main/java/org/telegram/messenger/BuildVars.java
     4: '014b35b6184100b085b0d0572f9b5103',
@@ -28,40 +89,33 @@
 
 API_ID: Final = int(os.environ['API_ID']) if os.environ.get('API_ID') else None
 API_HASH: Final = os.environ.get('API_HASH')
-TOKEN = os.environ.get('TOKEN')
-_chatid: Final = os.environ.get('CHATID')
-DELAY: Final = int(os.environ.get('DELAY', 300))
-
-if TOKEN is None or _chatid is None:
-    logging.critical('TOKEN OR CHATID NOT SET! PLEASE CHECK YOUR SETTINGS!')
-    exit(1)
+TOKEN: Final = os.environ.get('TOKEN')
 
 try:
-    CHATID: Final = int(_chatid) if _chatid.lstrip('-').isdecimal() else _chatid
-    del _chatid
-
-    _manager = os.environ.get('MANAGER', CHATID)
+    _chatid = os.environ.get('CHATID')
+    _chatid = int(_chatid) if isinstance(_chatid, str) and _chatid.lstrip('-').isdecimal() else _chatid
+    _manager = os.environ.get('MANAGER') or _chatid
     MANAGER: Final = int(_manager) if isinstance(_manager, str) and _manager.lstrip('-').isdecimal() else _manager
+    del _chatid
     del _manager
-except ValueError:
-    logging.critical('INVALID CHATID OR MANAGER! PLEASE CHECK YOUR SETTINGS!')
+
+    if not all((TOKEN, MANAGER)):
+        logging.critical('"TOKEN" OR "MANAGER" NOT SET! PLEASE CHECK YOUR SETTINGS!')
+        exit(1)
+except Exception as e:
+    logging.critical('INVALID "MANAGER"! PLEASE CHECK YOUR SETTINGS!', exc_info=e)
     exit(1)
 
-_telegraph_token = os.environ.get('TELEGRAPH_TOKEN')
-if _telegraph_token:
-    TELEGRAPH_TOKEN: Final = _telegraph_token.strip(). \
-        replace('\n', ',') \
-        .replace('，', ',') \
-        .replace(';', ',') \
-        .replace('；', ',') \
-        .replace(' ', ',')
-else:
-    TELEGRAPH_TOKEN: Final = None
+TELEGRAPH_TOKEN: Final = __list_parser(os.environ.get('TELEGRAPH_TOKEN'))
+
+MULTIUSER: Final = __bool_parser(os.environ.get('MULTIUSER'), default_value=True)
 
 # ----- proxy config -----
-DEFAULT_PROXY: Final = os.environ.get('SOCKS_PROXY', os.environ.get('HTTP_PROXY', None))
+DEFAULT_PROXY: Final = os.environ.get('SOCKS_PROXY') or os.environ.get('socks_proxy') \
+                       or os.environ.get('HTTP_PROXY') or os.environ.get('http_proxy') \
+                       or os.environ.get('HTTPS_PROXY') or os.environ.get('https_proxy')
 
-TELEGRAM_PROXY: Final = os.environ.get('T_PROXY', DEFAULT_PROXY)
+TELEGRAM_PROXY: Final = os.environ.get('T_PROXY') or DEFAULT_PROXY
 if TELEGRAM_PROXY:
     _parsed = parse_proxy_url(TELEGRAM_PROXY.replace('socks5h', 'socks5'))
     TELEGRAM_PROXY_DICT: Final = {
@@ -85,7 +139,7 @@
     TELEGRAM_PROXY_DICT: Final = None
     TELEGRAPH_PROXY_DICT: Final = None
 
-R_PROXY: Final = os.environ.get('R_PROXY', DEFAULT_PROXY)
+R_PROXY: Final = os.environ.get('R_PROXY') or DEFAULT_PROXY
 
 if R_PROXY:
     REQUESTS_PROXIES: Final = {
@@ -94,62 +148,59 @@
 else:
     REQUESTS_PROXIES: Final = {}
 
+PROXY_BYPASS_PRIVATE: Final = __bool_parser(os.environ.get('PROXY_BYPASS_PRIVATE'))
+PROXY_BYPASS_DOMAINS: Final = __list_parser(os.environ.get('PROXY_BYPASS_DOMAINS'))
+USER_AGENT: Final = os.environ.get('USER_AGENT') or 'RSStT/2.0 RSS Reader'
+IPV6_PRIOR: Final = __bool_parser(os.environ.get('IPV6_PRIOR'))
+
 # ----- img relay server config -----
-_img_relay_server = os.environ.get('IMG_RELAY_SERVER', 'https://rsstt-img-relay.rongrong.workers.dev/')
-IMG_RELAY_SERVER: Final = _img_relay_server + ('' if _img_relay_server.endswith('/') else '/')
+_img_relay_server = os.environ.get('IMG_RELAY_SERVER') or 'https://rsstt-img-relay.rongrong.workers.dev/'
+IMG_RELAY_SERVER: Final = _img_relay_server + ('' if _img_relay_server.endswith(('/', '=')) else '/')
 del _img_relay_server
 
-# ----- redis config -----
-REDIS_HOST: Final = os.environ.get('REDISHOST')
-REDIS_USER: Final = os.environ.get('REDISUSER')
-REDIS_PASSWORD: Final = os.environ.get('REDISPASSWORD')
-
-_redis_port = os.environ.get('REDISPORT')
-REDIS_PORT: Final = int(_redis_port) if _redis_port else None
-del _redis_port
-
-_redis_num = os.environ.get('REDIS_NUM')
-REDIS_NUM: Final = int(_redis_num) if _redis_num else None
-del _redis_num
+# ----- db config -----
+_database_url = os.environ.get('DATABASE_URL') or 'sqlite://config/db.sqlite3?journal_mode=OFF'
+DATABASE_URL: Final = (_database_url.replace('postgresql', 'postgres', 1) if _database_url.startswith('postgresql')
+                       else _database_url)
+del _database_url
 
 # ----- debug config -----
-if os.environ.get('DEBUG'):
-    DEBUG: Final = True
-else:
-    DEBUG: Final = False
-
-# ----- get version -----
-try:
-    with open('.version', 'r') as v:
-        _version = v.read().strip()
-except Exception:
-    _version = 'dirty'
-
-if _version == 'dirty':
-    from subprocess import Popen, PIPE, DEVNULL
-
-    try:
-        with Popen('git describe --tags', shell=True, stdout=PIPE, stderr=DEVNULL, bufsize=-1) as __:
-            __.wait(3)
-            _version = __.stdout.read().decode().strip()
-        with Popen('git branch --show-current', shell=True, stdout=PIPE, stderr=DEVNULL, bufsize=-1) as __:
-            __.wait(3)
-            __ = __.stdout.read().decode().strip()
-            if __:
-                _version += f'@{__}'
-    except Exception:
-        _version = 'dirty'
-
-if not _version or _version == '@':
-    _version = 'dirty'
-
-VERSION: Final = _version
-del _version
+DEBUG: Final = __bool_parser(os.environ.get('DEBUG'))
+
+# !!!!! DEPRECATED WARNING !!!!!
+if os.environ.get('DELAY'):
+    logging.warning('Env var "DELAY" is DEPRECATED and of no use!\n'
+                    'To avoid this warning, remove this env var.')
+
+if os.environ.get('CHATID'):
+    logging.warning('Env var "CHATID" is DEPRECATED!\n'
+                    'To avoid this warning, remove this env var.')
+
+if any((os.environ.get('REDISHOST'), os.environ.get('REDISUSER'), os.environ.get('REDISPASSWORD'),
+        os.environ.get('REDISPORT'), os.environ.get('REDIS_NUM'),)):
+    logging.warning('Redis DB is DEPRECATED!\n'
+                    'ALL SUBS IN THE OLD DB WILL NOT BE MIGRATED. '
+                    'IF YOU NEED TO BACKUP YOUR SUBS, DOWNGRADE AND USE "/export" COMMAND TO BACKUP.\n\n'
+                    'Please remove these env vars (if exist):\n'
+                    'REDISHOST\n'
+                    'REDISUSER\n'
+                    'REDISPASSWORD\n'
+                    'REDISPORT\n'
+                    'REDIS_NUM')
+
+if os.path.exists('config/rss.db'):
+    os.rename('config/rss.db', 'config/rss.db.bak')
+    logging.warning('Sqlite DB "rss.db" with old schema is DEPRECATED and renamed to "rss.db.bak" automatically!\n'
+                    'ALL SUBS IN THE OLD DB WILL NOT BE MIGRATED. '
+                    'IF YOU NEED TO BACKUP YOUR SUBS, DOWNGRADE AND USE "/export" COMMAND TO BACKUP.')
 
 # ----- shared var -----
 bot: Optional[TelegramClient] = None  # placeholder
 bot_id: Optional[int] = None  # placeholder
+bot_peer: Optional[User] = None  # placeholder
+bot_input_peer: Optional[InputPeerUser] = None  # placeholder
 
-REQUESTS_HEADERS: Final = {
-    'user-agent': os.environ.get('USER_AGENT', 'RSStT')
-}
+if os.name == "nt":  # workaround for aiodns on Windows
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
diff --git a/src/exceptions.py b/src/exceptions.py
new file mode 100644
index 0000000000..0bc17f6aa9
--- /dev/null
+++ b/src/exceptions.py
@@ -0,0 +1,7 @@
+from typing import Union
+
+
+class EntityNotFoundError(ValueError):
+    def __init__(self, peer: Union[int, str]):
+        self.peer = peer
+        super().__init__(f"Entity not found: {peer}")
diff --git a/src/feed.py b/src/feed.py
deleted file mode 100644
index 4ea385c1db..0000000000
--- a/src/feed.py
+++ /dev/null
@@ -1,279 +0,0 @@
-import asyncio
-import functools
-import aiohttp.client_exceptions
-import fasteners
-import feedparser
-import listparser
-from bs4 import BeautifulSoup
-from bs4.element import Tag
-from typing import Optional, Dict, Union, Iterator, List, MutableMapping, Tuple, Iterable
-from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor
-
-from src import log, env, web
-from src.db import db
-from src.parsing.post import get_post_from_entry
-
-logger = log.getLogger('RSStT.feed')
-
-_feedparser_thread_pool = ThreadPoolExecutor(1, 'feedparser_')
-
-
-class Feed:
-    def __init__(self, link: str, fid: Optional[int] = None, name: Optional[str] = None, last: Optional[str] = None):
-        self.fid = fid
-        self.name = name
-        self.link = link
-        self.last = last
-
-    async def monitor(self) -> Optional[bool]:
-        rss_d = await feed_get(self.link)
-        if rss_d is None:
-            return False
-
-        feed_last = str(rss_d.entries[0]['guid'] if 'guid' in rss_d.entries[0] else rss_d.entries[0]['link'])
-        if self.last == feed_last:
-            logger.debug(f'Fetched (not updated): {self.link}')
-            return None
-
-        last = self.last
-        self.last = feed_last
-        db.write(self.name, self.link, feed_last, True)  # update db
-
-        logger.info(f'Updated: {self.link}')
-        # Workaround, avoiding deleted post causing the bot send all posts in the feed.
-        # Known issues:
-        # If a post was deleted while another post was sent between feed fetching duration,
-        #  the latter won't be sent.
-        # If your bot has stopped for too long that last sent post do not exist in current RSS feed,
-        #  all posts won't be sent and last sent post will be reset to the newest post (though not sent).
-        end = None
-        for i in range(len(rss_d.entries)):
-            if last == str(rss_d.entries[i]['guid'] if 'guid' in rss_d.entries[i] else rss_d.entries[i]['link']):
-                end = i
-                break
-
-        if not end:  # end is None or end == 0
-            logger.warning(f'Cannot find the last sent post in current feed, all posts will not be sent: {self.link}')
-        else:
-            await self.send(env.CHATID, start=0, end=end, reverse=True, rss_d=rss_d)
-        return True
-
-    async def send(self, uid, start: int = 0, end: Optional[int] = 1, reverse: bool = False, rss_d=None,
-                   web_semaphore: Union[bool, asyncio.Semaphore] = None):
-        if rss_d is None:
-            rss_d = await feed_get(self.link, uid=uid, web_semaphore=web_semaphore)
-
-        if rss_d is None and uid is not None:
-            return  # error occurred and have notified user
-
-        if start >= len(rss_d.entries):
-            start = 0
-            end = 1
-        elif end is not None and start > 0 and start >= end:
-            end = start + 1
-
-        entries_to_send = rss_d.entries[start:end]
-        if reverse:
-            entries_to_send = entries_to_send[::-1]
-
-        await asyncio.gather(*(self._send(uid, entry, rss_d.feed.title) for entry in entries_to_send))
-
-    async def _send(self, uid, entry, feed_title):
-        post = get_post_from_entry(entry, feed_title, self.link)
-        await post.generate_message()
-        logger.debug(f"Sending {entry['title']} ({entry['link']})...")
-        await post.send_message(uid)
-
-    def __eq__(self, other):
-        return isinstance(other, Feed) and self.name == other.name
-
-    def __lt__(self, other):
-        if self.fid is None:
-            return True
-        return self.fid < other.fid
-
-
-class Feeds:
-    def __init__(self):
-        self._feeds = {fid: Feed(fid=fid, name=name, link=feed_url, last=last_url)
-                       for fid, (name, (feed_url, last_url)) in enumerate(db.read_all().items())}
-        self._lock = fasteners.ReaderWriterLock()
-        with open('src/opml_template.opml', 'r') as template:
-            self._opml_template = template.read()
-        self._interval = min(round(env.DELAY / 60), 60)  # cannot greater than 60
-
-    async def monitor(self, fetch_all: bool = False):
-        feeds_to_be_monitored: Iterable[Feed]
-        # acquire r lock
-        with self._lock.read_lock():
-            if fetch_all:
-                feeds_to_be_monitored = self._feeds.values()
-            else:
-                # divide monitor tasks evenly to every minute
-                sorted_feeds = sorted(self)
-                head = datetime.utcnow().minute % self._interval
-                feeds_to_be_monitored = sorted_feeds[head::self._interval]
-
-        if not feeds_to_be_monitored:  # nothing to do
-            return
-
-        logger.info('Started feeds monitoring task.')
-
-        result = await asyncio.gather(*(feed.monitor() for feed in feeds_to_be_monitored))
-
-        no_update = 0
-        fail = 0
-        updated = 0
-
-        for r in result:
-            if r is None:
-                no_update += 1
-                continue
-            if r:
-                updated += 1
-                continue
-            fail += 1
-
-        logger.info(f'Finished feeds monitoring task: '
-                    f'updated({updated}), not updated({no_update}), fetch failed({fail})')
-
-    @fasteners.lock.read_locked
-    def find(self, name: Optional[str] = None, link: Optional[str] = None, strict: bool = True) -> Optional[Feed]:
-        if not (name or link):
-            return
-        for feed in self._feeds.values():
-            if (name is None or feed.name == name) and (link is None or feed.link == link) if strict \
-                    else feed.name == name or feed.link == link:
-                return feed
-        return None
-
-    async def add_feed(self, name, link, uid: Optional[int] = None, timeout: Optional[int] = 10) \
-            -> Tuple[Union[bool, 'Feed'], Dict[str, Union[str, int]]]:
-        feed_dict = {'name': name, 'link': link, 'uid': uid}
-        if self.find(name, link, strict=False):
-            env.bot.send_message(uid, 'ERROR: 订阅名已被使用或 RSS 源已订阅') if uid else None
-            logger.warning(f'Refused to add an existing feed: {name} ({link})')
-            return False, feed_dict
-        rss_d = await feed_get(link, uid=uid, timeout=timeout)
-        if rss_d is None:
-            return False, feed_dict
-        last = str(rss_d.entries[0]['guid'] if 'guid' in rss_d.entries[0] else rss_d.entries[0]['link'])
-        fid = self.current_fid
-        feed = Feed(fid=fid, name=name, link=link, last=last)
-
-        # acquire w lock
-        with self._lock.write_lock():
-            self._feeds[fid] = feed
-            db.write(name, link, last)
-
-        logger.info(f'Added feed {link}.')
-        return feed, feed_dict
-
-    def del_feed(self, name):
-        feed_to_delete = self.find(name)
-        if feed_to_delete is None:
-            return None
-
-        # acquire w lock
-        with self._lock.write_lock():
-            self._feeds.pop(feed_to_delete.fid)
-            db.delete(name)
-
-        logger.info(f'Removed feed {name}.')
-        return feed_to_delete
-
-    @property
-    @fasteners.lock.read_locked
-    def current_fid(self):
-        return max(self._feeds.keys()) + 1 if self._feeds else 1
-
-    @fasteners.lock.read_locked
-    def get_user_feeds(self) -> Optional[tuple]:
-        if not self._feeds:
-            return None
-        else:
-            return tuple(self._feeds)
-
-    async def import_opml(self, opml_file: Union[bytearray, bytes]) -> Optional[Dict[str, list]]:
-        opml_d = listparser.parse(opml_file.decode())
-        if not opml_d.feeds:
-            return None
-        valid_feeds: List[MutableMapping] = []
-        invalid_feeds: List[MutableMapping] = []
-
-        coroutines = []
-        for _feed in opml_d.feeds:
-            if not _feed.title:
-                _feed.title = '不支持无标题订阅！'
-                invalid_feeds.append(_feed)
-                continue
-
-            _feed.title = _feed.title.replace(' ', '_')
-            coroutines.append(self.add_feed(name=_feed.title, link=_feed.url))
-
-        # do not need to acquire lock because add_feed will acquire one
-        result = await asyncio.gather(*coroutines)
-
-        for feed, feed_dict in result:
-            valid_feeds.append(feed_dict) if feed else invalid_feeds.append(feed_dict)
-
-        logger.info('Imported feed(s).')
-        return {'valid': valid_feeds, 'invalid': invalid_feeds}
-
-    @fasteners.lock.read_locked
-    def export_opml(self) -> Optional[bytes]:
-        opml = BeautifulSoup(self._opml_template, 'lxml-xml')
-        create_time = Tag(name='dateCreated')
-        create_time.string = datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S UTC')
-        opml.head.append(create_time)
-        empty_flags = True
-        for feed in self:
-            empty_flags = False
-            outline = Tag(name='outline', attrs={'text': feed.name, 'xmlUrl': feed.link})
-            opml.body.append(outline)
-        if empty_flags:
-            return None
-        logger.info('Exported feed(s).')
-        return opml.prettify().encode()
-
-    @fasteners.lock.read_locked
-    def __iter__(self) -> Iterator[Feed]:
-        return iter(self._feeds.values())
-
-    @fasteners.lock.read_locked
-    def __getitem__(self, item) -> Feed:
-        return self._feeds[item]
-
-
-async def feed_get(url: str, uid: Optional[int] = None, timeout: Optional[int] = None,
-                   web_semaphore: Union[bool, asyncio.Semaphore] = None):
-    try:
-        rss_content = await web.get(url, timeout, web_semaphore)
-        if len(rss_content) <= 524288:
-            rss_d = feedparser.parse(rss_content, sanitize_html=False)
-        else:  # feed too large, run in another thread to avoid blocking the bot
-            rss_d = await asyncio.get_event_loop().run_in_executor(_feedparser_thread_pool,
-                                                                   functools.partial(feedparser.parse, rss_content,
-                                                                                     sanitize_html=False))
-        if not rss_d.entries:
-            logger.warning(f'Fetch failed (feed error): {url}')
-            if uid:
-                await env.bot.send_message(uid, 'ERROR: 链接看起来不像是个 RSS 源，或该源不受支持')
-            return None
-    except aiohttp.client_exceptions.InvalidURL:
-        logger.warning(f'Fetch failed (URL invalid): {url}')
-        if uid:
-            await env.bot.send_message(uid, 'ERROR: URL 不合法')
-        return None
-    except (asyncio.exceptions.TimeoutError, aiohttp.client_exceptions.ClientError, ConnectionError, TimeoutError) as e:
-        logger.warning(f'Fetch failed (network error, {e.__class__.__name__}): {url}')
-        if uid:
-            await env.bot.send_message(uid, 'ERROR: 网络错误')
-        return None
-    except Exception as e:
-        logger.warning(f'Fetch failed: {url}', exc_info=e)
-        if uid:
-            await env.bot.send_message(uid, 'ERROR: 内部错误')
-        return None
-    return rss_d
diff --git a/src/i18n/README.md b/src/i18n/README.md
new file mode 100644
index 0000000000..df905c1797
--- /dev/null
+++ b/src/i18n/README.md
@@ -0,0 +1,3 @@
+# i18n
+
+Turn to the [translation guide](../../docs/translation-guide.md) for more information.
\ No newline at end of file
diff --git a/src/i18n/__init__.py b/src/i18n/__init__.py
new file mode 100644
index 0000000000..abace4cd00
--- /dev/null
+++ b/src/i18n/__init__.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+from typing import Optional
+
+from json import load
+from os import listdir, path
+from multidict import CIMultiDict, istr
+
+I18N_PATH = path.split(path.realpath(__file__))[0]
+ALL_LANGUAGES = tuple(lang[:-5] for lang in listdir(I18N_PATH) if lang.endswith('.json'))
+FALLBACK_LANGUAGE = istr('en')
+
+
+class _I18N:
+    __instance: Optional["_I18N"] = None
+    __initialized: bool = False
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__instance is None:
+            cls.__instance = super().__new__(cls)
+        return cls.__instance
+
+    def __init__(self):
+        if not self.__initialized:
+            self.__l10n_d: CIMultiDict[_L10N] = CIMultiDict()
+            self.__iso_639_d: CIMultiDict[str] = CIMultiDict()
+            for lang in ALL_LANGUAGES:
+                l10n = _L10N(lang)
+                iso_639_code = l10n['iso_639_code']
+                self.__l10n_d[lang] = l10n
+                if iso_639_code:
+                    self.__iso_639_d[iso_639_code] = lang
+
+            self.__initialized = True
+            self.set_help_msg_html()
+
+    def __getitem__(self, lang_code: Optional[str]) -> "_L10N":
+        if not lang_code or not isinstance(lang_code, str):
+            return self.get_fallback_l10n()
+        return self.__l10n_d[lang_code] if lang_code in self.__l10n_d else self.get_fallback_l10n(lang_code)
+
+    def get_all_l10n_string(self, key: str, html_escaped: bool = False,
+                            only_iso_639: bool = False) -> tuple[str, ...]:
+        languages = ALL_LANGUAGES if not only_iso_639 else self.__iso_639_d.keys()
+        res = (
+            tuple(self[lang_code][key] for lang_code in languages if self[lang_code].key_exist(key))
+            if not html_escaped else
+            tuple(self[lang_code].html_escaped(key) for lang_code in languages if self[lang_code].key_exist(key))
+        )
+        return res or (key,)
+
+    def get_fallback_l10n(self, lang_code: Optional[str] = None) -> "_L10N":
+        if not lang_code or not isinstance(lang_code, str):
+            return self.__l10n_d[FALLBACK_LANGUAGE]
+        iso_639_code = lang_code.split('-')[0].split('_')[0]
+        if iso_639_code in self.__iso_639_d:
+            return self.__l10n_d[self.__iso_639_d[iso_639_code]]
+        return self.__l10n_d[FALLBACK_LANGUAGE]
+
+    def set_help_msg_html(self):
+        cmd_lang_description = ' / '.join(self.get_all_l10n_string('cmd_description_lang', html_escaped=True,
+                                                                   only_iso_639=True))
+        for l10n in self.__l10n_d.values():
+            l10n_cmd_description_lang = l10n['cmd_description_lang']
+            _cmd_description_lang = (
+                    (f'{l10n_cmd_description_lang} / '
+                     if not l10n['iso_639_code'] and l10n_cmd_description_lang not in cmd_lang_description else '')
+                    + cmd_lang_description
+            )
+            help_msg_html = (
+                f"<a href='https://github.com/Rongronggg9/RSS-to-Telegram-Bot'>{l10n.html_escaped('rsstt_slogan')}</a>\n"
+                f"\n"
+                f"{l10n.html_escaped('commands')}:\n"
+                f"<b>/sub</b>: {l10n.html_escaped('cmd_description_sub')}\n"
+                f"<b>/unsub</b>: {l10n.html_escaped('cmd_description_unsub')}\n"
+                f"<b>/unsub_all</b>: {l10n.html_escaped('cmd_description_unsub_all')}\n"
+                f"<b>/list</b>: {l10n.html_escaped('cmd_description_list')}\n"
+                f"<b>/set</b>: {l10n.html_escaped('cmd_description_set')}\n"
+                f"<b>/import</b>: {l10n.html_escaped('cmd_description_import')}\n"
+                f"<b>/export</b>: {l10n.html_escaped('cmd_description_export')}\n"
+                f"<b>/activate_subs</b>: {l10n.html_escaped('cmd_description_activate_subs')}\n"
+                f"<b>/deactivate_subs</b>: {l10n.html_escaped('cmd_description_deactivate_subs')}\n"
+                f"<b>/version</b>: {l10n.html_escaped('cmd_description_version')}\n"
+                f"<b>/lang</b>: {_cmd_description_lang}\n"
+                f"<b>/help</b>: {l10n.html_escaped('cmd_description_help')}\n\n"
+            )
+            l10n.set_help_msg_html(help_msg_html)
+
+
+class _L10N:
+    def __init__(self, lang_code: str):
+        self.__lang_code: str = lang_code
+        self.__l10n_lang: CIMultiDict[str]
+        with open(path.join(I18N_PATH, lang_code + '.json'), encoding='utf-8') as f:
+            l10n_d = load(f)
+        l10n_d_flatten = {}
+        assert isinstance(l10n_d, dict)
+        for key, value in l10n_d.items():
+            assert isinstance(value, dict)
+            for k, v in value.items():
+                assert isinstance(v, str) and k not in l10n_d_flatten
+                l10n_d_flatten[k] = v
+        self.__l10n_lang = CIMultiDict(l10n_d_flatten)
+
+    def key_exist(self, key: str):
+        return key in self.__l10n_lang
+
+    def __getitem__(self, key: str):
+        if self.key_exist(key):
+            return self.__l10n_lang[key]
+        elif self.__lang_code != FALLBACK_LANGUAGE:
+            return _I18N().get_fallback_l10n(
+                self.__lang_code if not self.__l10n_lang['iso_639_code'] else None  # get ISO 639 fallback if needed
+            )[key]
+        else:
+            return key
+
+    def html_escaped(self, key: str):
+        return self[key].replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+
+    def set_help_msg_html(self, msg_html: str):
+        self.__l10n_lang['help_msg_html'] = msg_html
+
+
+i18n = _I18N()
diff --git a/src/i18n/en.json b/src/i18n/en.json
new file mode 100644
index 0000000000..c73d3582bb
--- /dev/null
+++ b/src/i18n/en.json
@@ -0,0 +1,123 @@
+{
+    "l10n_info": {
+        "lang_code": "en",
+        "iso_639_code": "en",
+        "language_name": "English",
+        "lang_native_name": "English",
+        "select_lang_prompt": "Please select a language.",
+        "welcome_prompt": "Welcome to RSS to Telegram Bot.",
+        "rsstt_slogan": "RSS to Telegram Bot, a Telegram RSS bot that cares about your reading experience."
+    },
+    "l10n_sub_status": {
+        "no_subscription": "You have no subscriptions",
+        "already_subscribed": "Already subscribed",
+        "subscription_not_exist": "Subscription does not exist"
+    },
+    "l10n_error_reasons": {
+        "feed_invalid": "The RSS feed is invalid",
+        "url_invalid": "The URL is invalid",
+        "network_error": "Network error",
+        "internal_error": "Internal error",
+        "status_code_error": "HTTP status code error",
+        "uncaught_internal_error": "Uncaught internal error",
+        "operation_timeout_error": "Operation timeout",
+        "action_invalid": "Action invalid",
+        "flood_wait_prompt": "You are operating too frequently that the bot has exceeded the rate limit of Telegram. Please slow down.",
+        "edit_conflict_prompt": "You are operating too frequently that operation conflicts. Please slow down.",
+        "callback_already_running_prompt": "You have requested another command. Please retry after if finishes."
+    },
+    "l10n_permission_denied_reasons": {
+        "permission_denied_not_bot_manager": "This command can only be used by the bot manager.",
+        "permission_denied_not_chat_admin": "This command can only be used by the admins of this group/channel.",
+        "permission_denied_not_in_private_chat": "This command can only be used in a private chat.",
+        "permission_denied_not_member": "You are not in this group/channel, thus cannot use the bot.",
+        "permission_denied_bot_not_member": "The bot is no longer in this group/channel, thus won't work here.",
+        "promote_to_admin_prompt": "If you are an anonymous admin of this group, please promote the bot to an admin (no permission needed) to empower the bot to verify your identity.",
+        "group_upgrade_needed_prompt": "Oops, your group hasn't been upgraded to a supergroup. Generally, the Telegram server should automatically perform this upgrade at some time, but if not, you have to upgrade it manually before you can use the bot.\nPlease follow these steps:\n1. Goto the group info, then click \"Manage group\"\n2. Change \"Chat history for new members\" to \"Visible\"\n3. Save chat history visibility setting\n4. Save all settings\n5. (Optional) If needed, you can change \"Chat history for new members\" to \"Hidden\" again\n6. Now you should be able to use the bot"
+    },
+    "l10n_misc": {
+        "subscribe": "Subscribe",
+        "unsubscribe": "Unsubscribe",
+        "subscription_list": "Subscription list",
+        "processing": "Processing, please wait for a moment…"
+    },
+    "l10n_cmd_sub": {
+        "sub_reply_feed_url_prompt_html": "Please reply the URL of an RSS feed. \nOr, you may use <code>/sub url1 url2 url3 …</code> to subscribe in bulk.",
+        "sub_usage_in_channel_html": "Please use <code>/sub url1 url2 url3 …</code> to subscribe.",
+        "sub_successful": "Subscribed successfully",
+        "sub_failed": "Subscribed failed"
+    },
+    "l10n_cmd_unsub": {
+        "unsub_choose_sub_prompt_html": "Please choose a subscription you'd like to unsubscribe. \nOr, you may use <code>/unsub url1 url2 url3 …</code> to unsubscribe in bulk.",
+        "unsub_successful": "Unsubscribed successfully",
+        "unsub_failed": "Unsubscribed failed"
+    },
+    "l10n_cmd_import": {
+        "send_opml_prompt": "Please send me the OPML file to be imported (extension name must be .opml).",
+        "send_opml_reply_placeholder": "The OPML file to be imported (extension name must be .opml)",
+        "fetch_file_failed": "Failed fetching the file",
+        "opml_import_processing": "If the number of feeds is large or feed servers are slow, it can be a long wait. Sit back and relax.",
+        "opml_parse_error": "OPML parsing error"
+    },
+    "l10n_cmd_set": {
+        "set_choose_sub_prompt": "Please choose a subscription you'd like to customize.",
+        "status": "Status",
+        "status_activated": "Activated",
+        "status_deactivated": "Deactivated",
+        "notification": "Notification",
+        "notification_normal": "Normal",
+        "notification_muted": "Muted",
+        "monitor_interval": "Monitor interval",
+        "set_interval_prompt": "Please select a monitor interval."
+    },
+    "l10n_choose_sub": {
+        "choose_sub_prompt": "Please choose a subscription",
+        "previous_page": "Previous page",
+        "next_page": "Next page",
+        "back": "Back"
+    },
+    "l10n_sub_info": {
+        "subscription_info": "Subscription info",
+        "subscription_title": "Subscription title",
+        "feed_url": "Feed URL"
+    },
+    "l10n_monitor_warn": {
+        "feed_deactivated_warn": "The monitoring task had failed for 100 consecutive times. Your subscription to the RSS feed has been deactivated.\nTo reactivate it, please use the /activate_subs command."
+    },
+    "l10n_cmd_activate": {
+        "choose_sub_to_be_activated": "The subscriptions below are deactivated, choose one to activate.\nAfter activated, their updates will be monitored.",
+        "activate_all_subs": "Activate all my subscriptions",
+        "all_subs_are_activated": "All subscriptions are activated."
+    },
+    "l10n_cmd_deactivate": {
+        "choose_sub_to_be_deactivated": "The subscriptions below are activated, choose one to deactivate.\nAfter deactivated, their updates will be suspended from monitoring. If you don't need the subscription any more, please consider unsubscribing it instead of deactivating it.",
+        "deactivate_all_subs": "Deactivate all my subscriptions",
+        "all_subs_are_deactivated": "All subscriptions are deactivated."
+    },
+    "l10n_administration": {
+        "test_cmd_usage_prompt_html": "Command usage: <code>/test RSS_URL entry_start_number(optional) entry_end_number(optional)</code>",
+        "set_option_cmd_usage_prompt_html": "Command usage: <code>/set_option key value</code>",
+        "current_options": "Current options",
+        "option_value_type": "Value type",
+        "option_key_invalid": "The Option key is invalid",
+        "option_value_invalid": "The Option value is invalid, please check its type",
+        "option_updated": "The option has been updated"
+    },
+    "l10n_cmd_descriptions": {
+        "commands": "Commands",
+        "cmd_description_sub": "Subscribe",
+        "cmd_description_unsub": "Unsubscribe",
+        "cmd_description_unsub_all": "Unsubscribe all subscriptions",
+        "cmd_description_list": "Check the subscription list",
+        "cmd_description_set": "Customize subscriptions",
+        "cmd_description_import": "Import subscriptions from an OPML file",
+        "cmd_description_export": "Export subscriptions to an OPML file",
+        "cmd_description_activate_subs": "Activate subscriptions",
+        "cmd_description_deactivate_subs": "Deactivate subscriptions",
+        "cmd_description_version": "Check the bot version",
+        "cmd_description_lang": "Select a language",
+        "cmd_description_help": "View help",
+        "cmd_description_test": "Test (bot manager only)",
+        "cmd_description_set_option": "Set bot options (bot manager only)"
+    }
+}
\ No newline at end of file
diff --git a/src/i18n/yue.json b/src/i18n/yue.json
new file mode 100644
index 0000000000..db455e0067
--- /dev/null
+++ b/src/i18n/yue.json
@@ -0,0 +1,123 @@
+{
+    "l10n_info": {
+        "lang_code": "yue",
+        "iso_639_code": "yue",
+        "language_name": "Cantonese",
+        "lang_native_name": "廣東話",
+        "select_lang_prompt": "請選擇語言。",
+        "welcome_prompt": "歡迎使用 RSS to Telegram Bot。",
+        "rsstt_slogan": "RSS to Telegram Bot，關心你嘅閲讀體驗嘅 Telegram RSS 機械人。"
+    },
+    "l10n_sub_status": {
+        "no_subscription": "冇訂閲",
+        "already_subscribed": "訂閲過喇",
+        "subscription_not_exist": "冇呢個訂閲"
+    },
+    "l10n_error_reasons": {
+        "feed_invalid": "RSS 無效",
+        "url_invalid": "連結唔啱",
+        "network_error": "網絡錯誤",
+        "internal_error": "內部錯誤",
+        "status_code_error": "HTTP 狀態碼錯誤",
+        "uncaught_internal_error": "冇捉到嘅內部錯誤",
+        "operation_timeout_error": "操作超時",
+        "action_invalid": "操作唔啱",
+        "flood_wait_prompt": "你操作得太快喇，搞到機械人超出咗 Telegram 嘅速率限制。唔該慢少少。",
+        "edit_conflict_prompt": "你操作得太快喇，搞到操作衝突。唔該慢少少。",
+        "callback_already_running_prompt": "你已經請求咗其他命令，唔該等佢搞掂再來過。"
+    },
+    "l10n_permission_denied_reasons": {
+        "permission_denied_not_bot_manager": "只有機械人嘅管理員先畀用呢條命令。",
+        "permission_denied_not_chat_admin": "只有谷/台嘅管理員先畀用呢條命令。",
+        "permission_denied_not_in_private_chat": "只有喺私人傾偈入面先畀用呢條命令。",
+        "permission_denied_not_member": "你唔喺呢個谷/台入面，用唔到呢個機械人。",
+        "permission_denied_bot_not_member": "呢個機械人已經唔喺呢個谷/台入面，唔會喺度運轉。",
+        "promote_to_admin_prompt": "如果你係呢個谷嘅匿名管理員，唔該將機械人升做管理員 (乜權限都唔洗)，咁機械人先可以驗證你嘅身份。",
+        "group_upgrade_needed_prompt": "弊！你嘅谷仲未係超級谷。一般來講，Telegram 嘅伺服器會喺某個時候自己搞掂呢個升級，但係如果佢冇咁做，除咗喺用呢個機械人之前自行升級呢個谷，就冇其他辦法。\n跟住我嚟：\n1. 入去谷嘅資料，撳「管理谷」\n2. 將「新成員嘅傾偈紀錄」改為「睇到」\n3. 儲存新成員嘅傾偈紀錄設定\n4. 儲存晒所有設定\n5. (可選) 如果你有需要，可以將「新成員嘅傾偈紀錄」改返「睇唔到」\n6. 而家你應該可以用呢個機械人喇"
+    },
+    "l10n_misc": {
+        "subscribe": "加訂閲",
+        "unsubscribe": "退訂",
+        "subscription_list": "訂閲清單",
+        "processing": "處理緊，唔該等陣…"
+    },
+    "l10n_cmd_sub": {
+        "sub_reply_feed_url_prompt_html": "唔該回復訂閲連結。\n或者，用 <code>/sub url1 url2 url3 …</code> 嚟批量訂閲都得。",
+        "sub_usage_in_channel_html": "唔該用 <code>/sub url1 url2 url3 …</code> 嚟訂閲。",
+        "sub_successful": "訂閲成功",
+        "sub_failed": "訂閲失敗"
+    },
+    "l10n_cmd_unsub": {
+        "unsub_choose_sub_prompt_html": "唔該選個你想退訂嘅訂閲。\n或者，用 <code>/unsub url1 url2 url3 …</code> 嚟批量退訂都得。",
+        "unsub_successful": "退訂成功",
+        "unsub_failed": "退訂失敗"
+    },
+    "l10n_cmd_import": {
+        "send_opml_prompt": "唔該送出要匯入嘅 OPML 檔案 (副檔名一定要係 .opml)。",
+        "send_opml_reply_placeholder": "OPML 檔案 (副檔名一定要係 .opml)",
+        "fetch_file_failed": "攞唔到檔案",
+        "opml_import_processing": "如果訂閲太多或者訂閲喺嘅伺服器太慢，可能會處理好耐，唔該多等陣。",
+        "opml_parse_error": "解讀唔到 OPML"
+    },
+    "l10n_cmd_set": {
+        "set_choose_sub_prompt": "唔該選個你想設定嘅訂閲。",
+        "status": "狀態",
+        "status_activated": "開",
+        "status_deactivated": "閂",
+        "notification": "通知",
+        "notification_normal": "正常",
+        "notification_muted": "靜音",
+        "monitor_interval": "監視間隔",
+        "set_interval_prompt": "唔該選個監視間隔。"
+    },
+    "l10n_choose_sub": {
+        "choose_sub_prompt": "唔該選個訂閲",
+        "previous_page": "上一頁",
+        "next_page": "下一頁",
+        "back": "返回"
+    },
+    "l10n_sub_info": {
+        "subscription_info": "訂閲資訊",
+        "subscription_title": "訂閲標題",
+        "feed_url": "RSS URL"
+    },
+    "l10n_monitor_warn": {
+        "feed_deactivated_warn": "監視任務已經連續失敗咗 100 次，對呢個 RSS 嘅訂閲已經畀閂咗。\n如果要開返佢，唔該用 /activate_subs 命令。"
+    },
+    "l10n_cmd_activate": {
+        "choose_sub_to_be_activated": "呢啲訂閲而家閂咗，唔該選個你想開返嘅訂閲。\n開返之後，會監視訂閲更新。",
+        "activate_all_subs": "開返晒我啲訂閲",
+        "all_subs_are_activated": "所有訂閲都開晒。"
+    },
+    "l10n_cmd_deactivate": {
+        "choose_sub_to_be_deactivated": "呢啲訂閲而家開咗，唔該選個你想閂嘅訂閲。\n閂咗之後，會暫停監視訂閲更新；如果你晤再需要呢個訂閲，唔該考慮吓退訂而唔係閂咗佢。",
+        "deactivate_all_subs": "閂晒我啲訂閲",
+        "all_subs_are_deactivated": "所有訂閲都閂晒。"
+    },
+    "l10n_administration": {
+        "test_cmd_usage_prompt_html": "命令用法: <code>/test RSS_URL 條目編號起點(選填) 條目編號終點(選填)</code>",
+        "set_option_cmd_usage_prompt_html": "命令用法: <code>/set_option 鍵 值</code>",
+        "current_options": "而家嘅選項",
+        "option_value_type": "值嘅類型",
+        "option_key_invalid": "選項嘅鍵唔啱",
+        "option_value_invalid": "選項嘅值唔啱，唔該檢查吓佢嘅類型",
+        "option_updated": "選項改咗"
+    },
+    "l10n_cmd_descriptions": {
+        "commands": "命令",
+        "cmd_description_sub": "加訂閲",
+        "cmd_description_unsub": "退訂",
+        "cmd_description_unsub_all": "退訂晒所有訂閲",
+        "cmd_description_list": "列出訂閲清單",
+        "cmd_description_set": "自訂訂閲設定",
+        "cmd_description_import": "從 OPML 匯入訂閲",
+        "cmd_description_export": "匯出訂閲到 OPML",
+        "cmd_description_activate_subs": "開訂閲",
+        "cmd_description_deactivate_subs": "閂訂閲",
+        "cmd_description_version": "檢查機械人版本",
+        "cmd_description_lang": "選擇語言",
+        "cmd_description_help": "睇幫助",
+        "cmd_description_test": "測試 (僅機械人管理員)",
+        "cmd_description_set_option": "改機械人選項 (僅機械人管理員)"
+    }
+}
\ No newline at end of file
diff --git a/src/i18n/zh-Hans.json b/src/i18n/zh-Hans.json
new file mode 100644
index 0000000000..e105550d8c
--- /dev/null
+++ b/src/i18n/zh-Hans.json
@@ -0,0 +1,123 @@
+{
+    "l10n_info": {
+        "lang_code": "zh-Hans",
+        "iso_639_code": "zh",
+        "language_name": "Simplified Chinese",
+        "lang_native_name": "简体中文",
+        "select_lang_prompt": "请选择语言。",
+        "welcome_prompt": "欢迎使用 RSS to Telegram Bot。",
+        "rsstt_slogan": "RSS to Telegram Bot，关心你的阅读体验的 Telegram RSS 机器人。"
+    },
+    "l10n_sub_status": {
+        "no_subscription": "无订阅",
+        "already_subscribed": "已被订阅",
+        "subscription_not_exist": "订阅不存在"
+    },
+    "l10n_error_reasons": {
+        "feed_invalid": "RSS 源不合法",
+        "url_invalid": "URL 不合法",
+        "network_error": "网络错误",
+        "internal_error": "内部错误",
+        "status_code_error": "HTTP 状态码错误",
+        "uncaught_internal_error": "未被捕捉的内部错误",
+        "operation_timeout_error": "操作超时",
+        "action_invalid": "操作不合法",
+        "flood_wait_prompt": "你的操作太快了，导致 bot 超过了 Telegram 的速率限制，请慢一点。",
+        "edit_conflict_prompt": "你的操作太快了，导致操作冲突，请慢一点。",
+        "callback_already_running_prompt": "你已经请求过其它命令，请等待它完成后重试。"
+    },
+    "l10n_permission_denied_reasons": {
+        "permission_denied_not_bot_manager": "此命令只可由机器人的管理员使用。",
+        "permission_denied_not_chat_admin": "此命令只可由群/频道管理员使用。",
+        "permission_denied_not_in_private_chat": "此命令只可在私聊中使用。",
+        "permission_denied_not_member": "你不在本群/频道里，不可以使用这个 bot。",
+        "permission_denied_bot_not_member": "本 bot 已经不在本群/频道里，不会在此工作。",
+        "promote_to_admin_prompt": "如果你是本群组的匿名管理员，请将 bot 提升为管理员 (不需要任何权限)，这样 bot 才能验证你的身份。",
+        "group_upgrade_needed_prompt": "哎呀，你的群组还没有被升级为一个超级群组。通常，Telegram 的服务器会在某个时候自动完成这个升级，但如果没有的话，你就不得不在使用这个 bot 之前手动升级它。\n请按以下步骤操作：\n1. 转到群组信息，点击「管理群组」\n2. 将「历史记录对新成员」设置为「可见」\n3. 保存历史记录可见性设置\n4. 保存所有设置\n5. (可选) 如果需要的话，你可以将「历史记录对新成员」重新设置为「不可见」\n6. 现在你应该可以使用这个 bot 了"
+    },
+    "l10n_misc": {
+        "subscribe": "添加订阅",
+        "unsubscribe": "退订订阅",
+        "subscription_list": "订阅列表",
+        "processing": "正在处理中，请稍候…"
+    },
+    "l10n_cmd_sub": {
+        "sub_reply_feed_url_prompt_html": "请回复订阅链接。\n或者，你也可以使用 <code>/sub url1 url2 url3 …</code> 来批量订阅。",
+        "sub_usage_in_channel_html": "请使用 <code>/sub url1 url2 url3 …</code> 来订阅。",
+        "sub_successful": "订阅成功",
+        "sub_failed": "订阅失败"
+    },
+    "l10n_cmd_unsub": {
+        "unsub_choose_sub_prompt_html": "请选择要退订的订阅。\n或者，你也可以使用 <code>/unsub url1 url2 url3 …</code> 来批量退订。",
+        "unsub_successful": "退订成功",
+        "unsub_failed": "退订失败"
+    },
+    "l10n_cmd_import": {
+        "send_opml_prompt": "请发送需要导入的 OPML 文件 (扩展名必须为 .opml)。",
+        "send_opml_reply_placeholder": "OPML 文件 (扩展名必须为 .opml)",
+        "fetch_file_failed": "获取文件失败",
+        "opml_import_processing": "如订阅较多或订阅所在的服务器太慢，将会处理较长时间，请耐心等待。",
+        "opml_parse_error": "OPML 解析错误"
+    },
+    "l10n_cmd_set": {
+        "set_choose_sub_prompt": "请选择你要设置的订阅。",
+        "status": "状态",
+        "status_activated": "已启用",
+        "status_deactivated": "已停用",
+        "notification": "通知",
+        "notification_normal": "正常",
+        "notification_muted": "静音",
+        "monitor_interval": "检查间隔",
+        "set_interval_prompt": "请选择检查间隔。"
+    },
+    "l10n_choose_sub": {
+        "choose_sub_prompt": "请选择订阅",
+        "previous_page": "上一页",
+        "next_page": "下一页",
+        "back": "返回"
+    },
+    "l10n_sub_info": {
+        "subscription_info": "订阅信息",
+        "subscription_title": "订阅标题",
+        "feed_url": "源 URL"
+    },
+    "l10n_monitor_warn": {
+        "feed_deactivated_warn": "检查任务已经连续失败 100 次，对该 RSS 源的订阅已被停用。\n若要重新启用，请使用 /activate_subs 命令。"
+    },
+    "l10n_cmd_activate": {
+        "choose_sub_to_be_activated": "以下订阅处于停用状态，请选择你需要启用的订阅。\n启用后，会监控订阅更新。",
+        "activate_all_subs": "启用我的全部订阅",
+        "all_subs_are_activated": "所有订阅都已启用。"
+    },
+    "l10n_cmd_deactivate": {
+        "choose_sub_to_be_deactivated": "以下订阅处于启用状态，请选择你需要停用的订阅。\n停用后，会暂停监控订阅更新；如果您永远不再需要这个订阅，请考虑退订而不是停用它。",
+        "deactivate_all_subs": "停用我的全部订阅",
+        "all_subs_are_deactivated": "所有订阅都已停用。"
+    },
+    "l10n_administration": {
+        "test_cmd_usage_prompt_html": "命令用法: <code>/test RSS_URL 条目编号起点(可选) 条目编号终点(可选)</code>",
+        "set_option_cmd_usage_prompt_html": "命令用法: <code>/set_option 键 值</code>",
+        "current_options": "目前的配置",
+        "option_value_type": "值类型",
+        "option_key_invalid": "配置的键不合法",
+        "option_value_invalid": "配置的值不合法，请检查其类型",
+        "option_updated": "配置已更新"
+    },
+    "l10n_cmd_descriptions": {
+        "commands": "命令",
+        "cmd_description_sub": "添加订阅",
+        "cmd_description_unsub": "退订订阅",
+        "cmd_description_unsub_all": "退订所有订阅",
+        "cmd_description_list": "列出订阅列表",
+        "cmd_description_set": "自定义订阅设置",
+        "cmd_description_import": "从 OPML 导入订阅",
+        "cmd_description_export": "导出订阅到 OPML",
+        "cmd_description_activate_subs": "启用订阅",
+        "cmd_description_deactivate_subs": "停用订阅",
+        "cmd_description_version": "查看 bot 版本",
+        "cmd_description_lang": "选择语言",
+        "cmd_description_help": "查看帮助",
+        "cmd_description_test": "测试 (仅 bot 管理员)",
+        "cmd_description_set_option": "更改 bot 配置 (仅 bot 管理员)"
+    }
+}
\ No newline at end of file
diff --git a/src/locks.py b/src/locks.py
new file mode 100644
index 0000000000..24239fc3b2
--- /dev/null
+++ b/src/locks.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from asyncio import BoundedSemaphore
+from collections import defaultdict
+from functools import partial
+from typing import Union
+from urllib.parse import urlparse
+
+from readerwriterlock.rwlock_async import RWLockWrite
+
+_USER_LIKE = Union[int, str]
+
+
+# ----- user locks -----
+
+class _UserLockBucket:
+    _max_concurrency_of_semaphore = 3
+
+    def __init__(self):
+        self.msg_semaphore = BoundedSemaphore(self._max_concurrency_of_semaphore)
+        self.msg_rwlock = RWLockWrite()
+        self.flood_rwlock = RWLockWrite()
+        self.pending_callbacks = set()
+
+
+_user_bucket: defaultdict[_USER_LIKE, _UserLockBucket] = defaultdict(_UserLockBucket)
+
+
+def user_msg_semaphore(user: _USER_LIKE) -> BoundedSemaphore:
+    return _user_bucket[user].msg_semaphore
+
+
+def user_msg_rwlock(user: _USER_LIKE) -> RWLockWrite:
+    return _user_bucket[user].msg_rwlock
+
+
+def user_flood_rwlock(user: _USER_LIKE) -> RWLockWrite:
+    return _user_bucket[user].flood_rwlock
+
+
+def user_msg_locks(user: _USER_LIKE) -> tuple[BoundedSemaphore, RWLockWrite, RWLockWrite]:
+    """
+    :return: user_msg_semaphore, user_msg_rwlock, user_flood_rwlock
+    """
+    return user_msg_semaphore(user), user_msg_rwlock(user), user_flood_rwlock(user)
+
+
+def user_pending_callbacks(user: _USER_LIKE) -> set:
+    return _user_bucket[user].pending_callbacks
+
+
+# ----- web locks -----
+_hostname_semaphore_bucket: defaultdict[str, BoundedSemaphore] = defaultdict(partial(BoundedSemaphore, 5))
+overall_web_semaphore = BoundedSemaphore(100)
+
+
+def hostname_semaphore(url: str, parse: bool = True) -> BoundedSemaphore:
+    hostname = urlparse(url).hostname if parse else url
+    return _hostname_semaphore_bucket[hostname]
+
+# Q: Why msg rwlock is needed?
+#
+# A: We are using an async telegram lib `telethon`. It sends messages asynchronously. Unfortunately,
+# sending messages to telegram is not "thread safe". Yup, you heard me right. That's all telegram's fault!
+#
+# In detail: Telegram needs time to send an album msg (media group msg) and each medium in the album is actually
+# a single media msg — telegram just displays them as an album. However, if we send multiple msgs (some of them
+# are album msgs), telegram cannot ensure that an album msg won't be interrupted by another msg. There's an
+# example. Each msg in a chat has its own id ("msg_id"). An album has no msg_id but each medium in the album has
+# a msg_id. Given that an empty chat (of no msg), let's send two msgs asynchronously — a media msg ("msg0") with
+# an image ("img0") and an album msg ("msg1") with four images ("img1"–"img4"). Sending msgs asynchronously means
+# that two sending requests will be sent almost at the same time. However, due to some reasons, for example,
+# an unstable network, it took a long time until img0 was uploaded successfully. Before that, img1 and img2 had
+# already been uploaded and were immediately sent to the chat by telegram. Img1 got the msg_id of 1 and img2 got
+# 2. Since telegram had received img0 at that moment, img0 (aka. msg0) was sent immediately and got the msg_id of
+# 3. Now the rest two images (img3 and img4) of msg1 were uploaded. Telegram sent them to the chat and gave them
+# msg_id of 4 and 5. You see, the msg_id 1,2,3,4,5 corresponded to img1,img2,img0,img3,img4 — msg1 was divided
+# into two parts! Some telegram apps (e.g. Telegram Desktop) can deal with a divided album properly while others
+# (e.g. Telegram for Android) cannot. On the latter, the two msgs becomes three msgs: album(img1,img2),
+# msg0(img0), album(img3,img4). Another issue is that sending album msgs is more easily to be flood-controlled
+# because telegram treat each medium as a single msg. Therefore, sending non-media-group msg asynchronously is
+# acceptable but sending media group msg must wait for any pending sending requests to finish and blocking any
+# coming sending requests. Rwlock fits the demand.
+#
+# TL;DR: To avoid album msg being interrupted on some telegram apps and to avoid getting flood-controlled
+# frequently.
diff --git a/src/log.py b/src/log.py
index 3aa7492133..82e0e95d52 100644
--- a/src/log.py
+++ b/src/log.py
@@ -1,5 +1,7 @@
+import asyncio
 import logging
 import colorlog
+from threading import Thread
 
 from src import env
 
@@ -7,18 +9,18 @@
 
 colorlog.basicConfig(format='%(log_color)s%(asctime)s:%(levelname)s:%(name)s - %(message)s',
                      datefmt='%Y-%m-%d-%H:%M:%S',
-                     level=logging.DEBUG if env.DEBUG else logging.INFO)
+                     level=colorlog.DEBUG if env.DEBUG else colorlog.INFO)
 
 _muted = colorlog.INFO if env.DEBUG else colorlog.WARNING
 _shut_upped = colorlog.ERROR if env.DEBUG else colorlog.CRITICAL
 
-getLogger("telegram").setLevel(colorlog.INFO)
-getLogger("requests").setLevel(_shut_upped)
-getLogger("urllib3").setLevel(_shut_upped)
-getLogger('apscheduler').setLevel(_muted)
+getLogger('apscheduler').setLevel(colorlog.WARNING)
 getLogger('aiohttp_retry').setLevel(_muted)
 getLogger('asyncio').setLevel(_muted)
 getLogger('telethon').setLevel(_muted)
+getLogger('aiosqlite').setLevel(_muted)
+getLogger('tortoise').setLevel(_muted)
+getLogger('asyncpg').setLevel(_muted)
 
 
 # flit log from apscheduler.scheduler
@@ -31,12 +33,16 @@ def filter(self, record: logging.LogRecord) -> bool:
         msg = record.msg % record.args
         if 'skipped: maximum number of running instances reached' in msg:
             self.count += 1
-            if self.count % 10 == 0:
-                env.bot.send_message(
-                    env.MANAGER, 'RSS 更新检查发生冲突，程序可能出现问题，请记录日志并重启。\n'
-                                 '（这也可能是由过短的检查间隔和过多的订阅引起，请适度调整后观察是否还有错误）\n\n'
-                                 + msg
+            if self.count % 5 == 0:
+                if self.count >= 15:
+                    exit(-1)
+                coro = env.bot.send_message(
+                    env.MANAGER,
+                    'RSS monitor tasks have conflicted too many times! Please store the log and restart.\n'
+                    ' (sometimes it may be caused by too many subscriptions)\n\n'
+                    + msg
                 )
+                Thread(target=asyncio.run, args=(coro,)).start()
             return True
         if ' executed successfully' in msg:
             self.count = -3  # only >= 4 consecutive failures lead to a manager warning
diff --git a/src/message.py b/src/message.py
index b1c9896ae1..02a88e79f8 100644
--- a/src/message.py
+++ b/src/message.py
@@ -1,12 +1,12 @@
-from collections import defaultdict
-from typing import List, Union, Optional, Tuple, Dict
+from __future__ import annotations
+from typing import Union, Optional
+
+import asyncio
 from telethon.tl.types import DocumentAttributeVideo, DocumentAttributeAnimated
-from telethon.errors.rpcerrorlist import FloodError
-from readerwriterlock.rwlock_async import RWLockWrite
+from telethon.errors.rpcerrorlist import SlowModeWaitError, FloodWaitError
 from asyncio import BoundedSemaphore
-from functools import partial
 
-from src import log, env
+from src import log, env, locks
 from src.parsing.medium import Medium
 
 logger = log.getLogger('RSStT.message')
@@ -14,73 +14,58 @@
 
 class Message:
     no_retry = False
-    __max_concurrency = 3
-    __semaphore_bucket: Dict[Union[int, str], BoundedSemaphore] = defaultdict(
-        partial(BoundedSemaphore, __max_concurrency))
-    __lock_bucket: Dict[Union[int, str], RWLockWrite] = defaultdict(RWLockWrite)
-    __lock_type = 'r'
+    __overall_concurrency = 30
+    __overall_semaphore = BoundedSemaphore(__overall_concurrency)
 
-    # Q: Why rwlock is needed?
-    #
-    # A: We are using an async telegram lib `telethon`. It sends messages asynchronously. Unfortunately,
-    # sending messages to telegram is not "thread safe". Yup, you heard me right. That's all telegram's fault!
-    #
-    # In detail: Telegram needs time to send an album msg (media group msg) and each medium in the album is actually
-    # a single media msg — telegram just displays them as an album. However, if we send multiple msgs (some of them
-    # are album msgs), telegram cannot ensure that an album msg won't be interrupted by another msg. There's an
-    # example. Each msg in a chat has its own id ("msg_id"). An album has no msg_id but each medium in the album has
-    # a msg_id. Given that an empty chat (of no msg), let's send two msgs asynchronously — a media msg ("msg0") with
-    # an image ("img0") and an album msg ("msg1") with four images ("img1"–"img4"). Sending msgs asynchronously means
-    # that two sending requests will be sent almost at the same time. However, due to some reasons, for example,
-    # an unstable network, it took a long time until img0 was uploaded successfully. Before that, img1 and img2 had
-    # already been uploaded and were immediately sent to the chat by telegram. Img1 got the msg_id of 1 and img2 got
-    # 2. Since telegram had received img0 at that moment, img0 (aka. msg0) was sent immediately and got the msg_id of
-    # 3. Now the rest two images (img3 and img4) of msg1 were uploaded. Telegram sent them to the chat and gave them
-    # msg_id of 4 and 5. You see, the msg_id 1,2,3,4,5 corresponded to img1,img2,img0,img3,img4 — msg1 was divided
-    # into two parts! Some telegram apps (e.g. Telegram Desktop) can deal with a divided album properly while others
-    # (e.g. Telegram for Android) cannot. On the latter, the two msgs becomes three msgs: album(img1,img2),
-    # msg0(img0), album(img3,img4). Another issue is that sending album msgs is more easily to be flood-controlled
-    # because telegram treat each medium as a single msg. Therefore, sending non-media-group msg asynchronously is
-    # acceptable but sending media group msg must wait for any pending sending requests to finish and blocking any
-    # coming sending requests. Rwlock fits the demand.
-    #
-    # TL;DR: To avoid album msg being interrupted on some telegram apps and to avoid getting flood-controlled
-    # frequently.
+    __lock_type = 'r'
 
     def __init__(self,
                  text: Optional[str] = None,
-                 media: Optional[Union[List[Medium], Tuple[Medium], Medium]] = None,
+                 media: Optional[Union[list[Medium], list[Medium], Medium]] = None,
                  parse_mode: Optional[str] = 'HTML'):
         self.text = text
         self.media = media
         self.parse_mode = parse_mode
         self.retries = 0
 
-    async def send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
-        # do not need flood control waiting or network error retrying because telethon will automatically perform them
-        try:
-            rwlock = self.__lock_bucket[chat_id]
-            rlock_or_wlock = (await rwlock.gen_wlock() if self.__lock_type == 'w' else await rwlock.gen_rlock())
-            semaphore = self.__semaphore_bucket[chat_id]
-            async with rlock_or_wlock:
-                async with semaphore:
-                    await self._send(chat_id, reply_to_msg_id)
-        except FloodError:  # telethon has retried due to flood control for too many times
-            logger.warning('Msg dropped due to too many flood control retries')
-            return
-
-    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
+    async def send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
+        semaphore, rwlock, flood_rwlock = locks.user_msg_locks(chat_id)
+        rlock_or_wlock = await rwlock.gen_wlock() if self.__lock_type == 'w' else await rwlock.gen_rlock()
+        flood_rlock_or_wlock = await flood_rwlock.gen_rlock()  # always acquire a read lock first
+
+        async with semaphore:  # acquire user semaphore first to reduce per user concurrency
+            while True:
+                try:
+                    async with rlock_or_wlock:  # acquire a msg rwlock
+                        async with flood_rlock_or_wlock:  # acquire a flood rwlock
+                            async with self.__overall_semaphore:  # only acquire overall semaphore when sending
+                                await self._send(chat_id, reply_to_msg_id, silent)
+                    return
+                except (FloodWaitError, SlowModeWaitError) as e:
+                    # telethon has retried for us, but we release locks and retry again here to see if it will be better
+                    if self.retries >= 1:
+                        logger.error(f'Msg dropped due to too many flood control retries ({chat_id})')
+                        return
+
+                    self.retries += 1
+                    flood_rlock_or_wlock = await flood_rwlock.gen_wlock()  # enforce a wlock here block other attempts
+                    if not flood_rwlock.v_write_count:  # only flood wait once, thus only lock once
+                        async with flood_rlock_or_wlock:  # acquire a flood rwlock
+                            await asyncio.sleep(e.seconds + 1)  # sleep
+
+    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         pass
 
 
 class TextMsg(Message):
     link_preview = False
 
-    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
+    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         await env.bot.send_message(chat_id, self.text,
                                    parse_mode=self.parse_mode,
                                    link_preview=self.link_preview,
-                                   reply_to=reply_to_msg_id)
+                                   reply_to=reply_to_msg_id,
+                                   silent=silent)
 
 
 class BotServiceMsg(TextMsg):
@@ -96,37 +81,43 @@ class MediaMsg(Message):
 
 
 class PhotoMsg(MediaMsg):
-    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
+    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         await env.bot.send_message(chat_id, self.text,
                                    file=self.media.telegramize(),
                                    parse_mode=self.parse_mode,
-                                   reply_to=reply_to_msg_id)
+                                   reply_to=reply_to_msg_id,
+                                   silent=silent)
 
 
 class VideoMsg(MediaMsg):
-    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
+    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         await env.bot.send_message(chat_id, self.text,
                                    file=self.media.telegramize(),
                                    attributes=(DocumentAttributeVideo(0, 0, 0),),
                                    parse_mode=self.parse_mode,
-                                   reply_to=reply_to_msg_id)
+                                   reply_to=reply_to_msg_id,
+                                   silent=silent)
 
 
 class AnimationMsg(MediaMsg):
-    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
+    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         await env.bot.send_message(chat_id, self.text,
                                    file=self.media.telegramize(),
                                    attributes=(DocumentAttributeAnimated(),),
                                    parse_mode=self.parse_mode,
-                                   reply_to=reply_to_msg_id)
+                                   reply_to=reply_to_msg_id,
+                                   silent=silent)
 
 
 class MediaGroupMsg(MediaMsg):
     __lock_type = 'w'
 
-    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None):
+    async def _send(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         media_list = list(map(lambda m: m.telegramize(), self.media))
+        await asyncio.sleep(0.25)  # extra sleep to avoid flood control
         await env.bot.send_message(chat_id, self.text,
                                    file=media_list,
                                    parse_mode=self.parse_mode,
-                                   reply_to=reply_to_msg_id)
+                                   reply_to=reply_to_msg_id,
+                                   silent=silent)
+        await asyncio.sleep(0.25)  # extra sleep to avoid flood control
diff --git a/src/parsing/html_text.py b/src/parsing/html_text.py
new file mode 100644
index 0000000000..bafa9a2d3d
--- /dev/null
+++ b/src/parsing/html_text.py
@@ -0,0 +1,274 @@
+from typing import Optional, Union
+
+
+class Text:
+    tag: Optional[str] = None
+    attr: Optional[str] = None
+
+    def __init__(self, content: Union["Text", str, list], param: Optional[str] = None, *_args, **_kwargs):
+        if content is None:
+            content = ''
+        self.param = param
+        if type(content) is type(self) or type(content) is Text:
+            self.content = content.content
+        elif type(content) is str:
+            self.content = content.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+        else:
+            self.content = content
+
+    def is_nested(self):
+        return type(self.content) is not str
+
+    def is_listed(self):
+        return type(self.content) is list
+
+    def copy(self):
+        if not self.is_nested():
+            return self
+        return type(self)(self.content.copy(), self.param, copy=True)
+
+    def strip(self, deeper: bool = False, strip_l: Optional[bool] = True, strip_r: Optional[bool] = True):
+        if not self.is_nested():  # str
+            if strip_l:
+                self.content.lstrip()
+            if strip_r:
+                self.content.rstrip()
+        if not self.is_listed():  # nested
+            if not deeper:
+                return
+            self.content.strip()
+        while strip_l and self.content and type(self.content[0]) is Br:
+            self.content.pop(0)
+        while strip_r and self.content and type(self.content[-1]) is Br:
+            self.content.pop()
+        if deeper:
+            any(map(lambda text: text.strip(strip_l=strip_l, strip_r=strip_r), self.content))
+
+    def lstrip(self, deeper: bool = False):
+        self.strip(deeper=deeper, strip_r=False)
+
+    def rstrip(self, deeper: bool = False):
+        self.strip(deeper=deeper, strip_l=False)
+
+    def get_html(self, plain: bool = False):
+        if self.is_listed():
+            result = ''
+            for subText in self.content:
+                result += subText.get_html(plain=plain)
+        elif self.is_nested():
+            result = self.content.get_html(plain=plain)
+        else:
+            result = self.content
+
+        if plain:
+            return result.replace('\n', '')
+
+        if self.attr and self.param:
+            return f'<{self.tag} {self.attr}="{self.param}">{result}</{self.tag}>'
+        if self.tag:
+            return f'<{self.tag}>{result}</{self.tag}>'
+        return result
+
+    def split_html(self, length_limit_head: int, head_count: int = -1, length_limit_tail: int = 4096) -> list:
+        split_list = []
+        # TODO: when result to be yield < length_limit*0.5, add subSubText to it
+        if type(self.content) == list:
+            curr_length = 0
+            subText = None
+            split_count = 0
+            result = ''
+            length = 0
+            for subText in self.content:
+                curr_length = len(subText)
+                curr_length_limit = length_limit_head if head_count == -1 or split_count < head_count \
+                    else length_limit_tail
+                if length + curr_length >= curr_length_limit and result:
+                    stripped = result.strip()
+                    result = ''
+                    length = 0
+                    if stripped:
+                        split_count += 1
+                        curr_length_limit = length_limit_head if head_count == -1 or split_count < head_count \
+                            else length_limit_tail
+                        split_list.append(stripped)  # split
+                if curr_length >= curr_length_limit:
+                    for subSubText in subText.split_html(curr_length_limit):
+                        split_count += 1
+                        split_list.append(subSubText)  # split
+                    continue
+                length += curr_length
+                result += subText.get_html()
+
+            curr_length_limit = length_limit_head if head_count == -1 or split_count < head_count \
+                else length_limit_tail
+            if length < curr_length_limit and result:
+                stripped = result.strip()
+                if stripped:
+                    split_list.append(stripped)  # split
+            elif curr_length >= curr_length_limit and subText:
+                for subSubText in subText.split_html(curr_length_limit):
+                    split_list.append(subSubText)  # split
+
+            return split_list
+
+        if type(self.content) == str:
+            result = self.content
+            if len(result) >= length_limit_head:
+                split_list = [result[i:i + length_limit_head - 1]
+                              for i in range(0, len(result), length_limit_head - 1)]  # split
+        else:  # nested
+            split_list = self.content.split_html(length_limit_head)  # split
+
+        return [f'<{self.tag} {self.attr}={self.param}>{text}</{self.tag}>' if self.attr and self.param
+                else (f'<{self.tag}>{text}</{self.tag}>' if self.tag
+                      else text)
+                for text in split_list]
+
+    def find_instances(self, _class, shallow: Optional[bool] = False) -> Optional[list]:
+        result = []
+        if isinstance(self, _class):
+            result.append(self)
+        if self.is_listed():
+            if shallow:
+                return [subText for subText in self.content if isinstance(subText, _class)]
+            for subText in self.content:
+                instance = subText.find_instances(_class)
+                if instance:
+                    result.extend(instance)
+            return result if result else None
+        if self.is_nested():
+            instance = self.content.find_instances(_class, shallow)
+            if instance:
+                result.extend(instance)
+        return result if result else None
+
+    def __len__(self):
+        length = 0
+        if type(self.content) == list:
+            for subText in self.content:
+                length += len(subText)
+            return length
+        return len(self.content)
+
+    def __bool__(self):
+        return bool(self.content)
+
+    def __eq__(self, other):
+        return type(self) == type(other) and self.content == other.content and self.param == other.param
+
+    def __repr__(self):
+        return f'{type(self).__name__}:{repr(self.content)}'
+
+    def __str__(self):
+        return self.get_html()
+
+
+# ---- HTML tags super class ----
+class TagWithParam(Text):
+    pass
+
+
+class TagWithoutParam(Text):
+    def __init__(self, content: Union["Text", str, list], *_args, **_kwargs):
+        super().__init__(content)
+
+
+class ListParent(TagWithoutParam):
+    pass
+
+
+# ---- HTML tags ----
+class Link(TagWithParam):
+    tag = 'a'
+    attr = 'href'
+
+
+class Bold(TagWithoutParam):
+    tag = 'b'
+
+
+class Italic(TagWithoutParam):
+    tag = 'i'
+
+
+class Underline(TagWithoutParam):
+    tag = 'u'
+
+
+class Strike(TagWithoutParam):
+    tag = 's'
+
+
+class Code(TagWithParam):
+    tag = 'code'
+    attr = 'class'
+
+
+class Pre(TagWithoutParam):
+    tag = 'pre'
+
+
+class Br(TagWithoutParam):
+    def __init__(self, count: int = 1, *_args, **_kwargs):
+        if not isinstance(count, int):
+            count = 1
+        super().__init__('\n' * count)
+
+    def get_html(self, plain: bool = False):
+        if plain:
+            return ''
+        return super().get_html()
+
+
+class Hr(TagWithoutParam):
+    def __init__(self, *_args, **_kwargs):
+        super().__init__('\n----------------------\n')
+
+    def get_html(self, plain: bool = False):
+        if plain:
+            return ''
+        return super().get_html()
+
+
+class ListItem(TagWithoutParam):
+    def __init__(self, content, *_args, copy: bool = False, **_kwargs):
+        super().__init__(content)
+        if copy:
+            return
+        nested_lists = self.find_instances(ListParent)
+        if not nested_lists:
+            return
+        for nested_list in nested_lists:
+            nested_list.rstrip()
+            nested_list_items = nested_list.find_instances(ListItem, shallow=True)
+            if not nested_list_items:
+                return
+            for nested_list_item in nested_list_items:
+                nested_list_item.content = [Text('    '), Text(nested_list_item.content)]
+            nested_list_items[-1].rstrip(deeper=True)
+
+
+class OrderedList(ListParent):
+    def __init__(self, content, *_args, copy: bool = False, **_kwargs):
+        super().__init__(content)
+        if copy:
+            return
+        list_items = self.find_instances(ListItem, shallow=True)
+        if not list_items:
+            return
+        index = 1
+        for list_item in list_items:
+            list_item.content = [Bold(f'{index}. '), Text(list_item.content), Br()]
+            index += 1
+
+
+class UnorderedList(ListParent):
+    def __init__(self, content, *_args, copy: bool = False, **_kwargs):
+        super().__init__(content)
+        if copy:
+            return
+        list_items = self.find_instances(ListItem, shallow=True)
+        if not list_items:
+            return
+        for list_item in list_items:
+            list_item.content = [Bold(f'● '), Text(list_item.content), Br()]
diff --git a/src/parsing/medium.py b/src/parsing/medium.py
index 33a5f3151a..d35a26855a 100644
--- a/src/parsing/medium.py
+++ b/src/parsing/medium.py
@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import asyncio
 import re
 from telethon.tl.types import InputMediaPhotoExternal, InputMediaDocumentExternal
-from typing import List
 
 from src import env, log, web
 from src.parsing import post
@@ -37,8 +38,11 @@ def get_link(self, only_invalid: bool = True):
     def get_url(self):
         return self.url
 
-    def invalidate(self):
-        self.valid = False
+    def invalidate(self) -> bool:
+        if self.valid:
+            self.valid = False
+            return True
+        return False
 
     async def validate(self):  # warning: only design for weibo
         if self.valid is not None:  # already validated
@@ -85,11 +89,15 @@ def __bool__(self):
     def __eq__(self, other):
         return type(self) == type(other) and self.original_url == other.original_url
 
-    def change_server(self):
+    async def change_server(self):
         if self._server_change_count >= 1:
             return False
         self._server_change_count += 1
         self.url = env.IMG_RELAY_SERVER + self.url
+        try:
+            await web.get(url=self.url, semaphore=False, no_body=True)  # let the img relay sever cache the img
+        except Exception:
+            pass
         return True
 
 
@@ -100,9 +108,9 @@ class Image(Medium):
     def telegramize(self):
         return InputMediaPhotoExternal(self.url)
 
-    def change_server(self):
+    async def change_server(self):
         if not serverParser.search(self.url):  # is not a weibo img
-            return super().change_server()
+            return await super().change_server()
 
         if self._server_change_count >= 4:
             return False
@@ -131,15 +139,15 @@ def telegramize(self):
 
 class Media:
     def __init__(self):
-        self._media: List[Medium] = []
+        self._media: list[Medium] = []
 
     def add(self, medium: Medium):
         if medium in self._media:
             return
         self._media.append(medium)
 
-    def invalidate_all(self):
-        any(map(lambda m: m.invalidate(), self._media))
+    def invalidate_all(self) -> bool:
+        return bool(self._media and sum(media.invalidate() for media in self._media))
 
     async def validate(self):
         if not self._media:
@@ -173,10 +181,8 @@ def get_valid_media(self):
     def get_invalid_link(self):
         return tuple(m.get_link(only_invalid=True) for m in self._media if not m)
 
-    def change_all_server(self):
-        if sum(map(lambda m: m.change_server(), self._media)):
-            return True
-        return False
+    async def change_all_server(self):
+        return bool(self._media and sum(await asyncio.gather(*(media.change_server() for media in self._media))))
 
     def __len__(self):
         return len(self._media)
diff --git a/src/parsing/post.py b/src/parsing/post.py
index fd2a745bab..05fa41c59a 100644
--- a/src/parsing/post.py
+++ b/src/parsing/post.py
@@ -1,28 +1,37 @@
+from __future__ import annotations
+from collections.abc import Iterator, Iterable
+
 import json
 import re
 import traceback
-import asyncio.exceptions
+import asyncio
 from bs4 import BeautifulSoup
-from bs4.element import NavigableString
-from typing import Optional, Union, List, Iterator
+from bs4.element import NavigableString, PageElement, Tag
 from emoji import emojize
 from urllib.parse import urlparse, urljoin
 from aiographfix import exceptions
 from aiohttp import ClientError
 from html import unescape
 
-# errors caused by invalid img/video(s)
-from telethon.errors.rpcerrorlist import PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoInvalidError, \
-    PhotoCropSizeSmallError, PhotoContentUrlEmptyError, PhotoContentTypeInvalidError, \
-    GroupedMediaInvalidError, MediaGroupedInvalidError, MediaInvalidError, \
-    VideoContentTypeInvalidError, VideoFileInvalidError
+from telethon.errors.rpcerrorlist import (
+    # errors caused by invalid img/video(s)
+    PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoInvalidError,
+    PhotoCropSizeSmallError, PhotoContentUrlEmptyError, PhotoContentTypeInvalidError,
+    GroupedMediaInvalidError, MediaGroupedInvalidError, MediaInvalidError,
+    VideoContentTypeInvalidError, VideoFileInvalidError, ExternalUrlInvalidError,
+
+    # errors caused by server instability or network instability between img server and telegram server
+    WebpageCurlFailedError, WebpageMediaEmptyError, MediaEmptyError, FileReferenceExpiredError,
+    BadRequestError,  # only FILE_REFERENCE_\d_EXPIRED
 
-# errors caused by server instability or network instability between img server and telegram server
-from telethon.errors.rpcerrorlist import WebpageCurlFailedError, WebpageMediaEmptyError, MediaEmptyError
+    # errors caused by lack of permission
+    UserIsBlockedError, UserIdInvalidError, ChatWriteForbiddenError, ChannelPrivateError
+)
 
 from src import env, message, log, web
 from src.parsing import tgraph
 from src.parsing.medium import Video, Image, Media, Animation
+from src.parsing.html_text import *
 
 logger = log.getLogger('RSStT.post')
 
@@ -38,6 +47,7 @@
 stripNewline = re.compile(r'\n{3,}', )
 stripLineEnd = re.compile(r'[ \t\xa0]+\n')
 isEmoticon = re.compile(r'(width|height): ?(([012]?\d|30)(\.\d)?px|[01](\.\d)?em)')
+fileReferenceNExpired = re.compile(r'FILE_REFERENCE_(?:\d_)?EXPIRED')
 
 # load emoji dict
 with open('src/parsing/emojify.json', 'r', encoding='utf-8') as emojify_json:
@@ -69,9 +79,9 @@ def get_post_from_entry(entry, feed_title: str, feed_link: str = None) -> 'Post'
                 content = content[0]
         content = content.get('value', '')
 
-    link = entry['link']
+    link = entry.get('link') or entry.get('guid')
     author = entry['author'] if ('author' in entry and type(entry['author']) is str) else None
-    title = entry['title']
+    title = entry.get('title')  # hmm, some entries do have no title, should we really set up a feed hospital?
     return Post(content, title, feed_title, link, author, feed_link=feed_link)
 
 
@@ -109,7 +119,7 @@ def __init__(self,
         self.text = Text('')
         self.service_msg = service_msg
         self.telegraph_url = telegraph_url
-        self.messages: Optional[List[message.Message]] = None
+        self.messages: Optional[list[message.Message]] = None
         self.origin_text = self.text.copy()
         self.title = emojify(unescape(title.strip())) if title else None
         self.feed_title = feed_title
@@ -128,91 +138,106 @@ async def generate_text(self):
         self._add_metadata()
         self._add_invalid_media()
 
-    async def send_message(self, chat_ids: Union[List[Union[str, int]], str, int], reply_to_msg_id: int = None):
+    async def send_message(self, chat_id: Union[str, int], reply_to_msg_id: int = None, silent: bool = None):
         if not self.messages and not self.telegraph_post:
             await self.generate_message()
 
         if self.telegraph_post:
-            await self.telegraph_post.send_message(chat_ids, reply_to_msg_id)
+            await self.telegraph_post.send_message(chat_id, reply_to_msg_id, silent)
             return
 
-        if type(chat_ids) is not list:
-            chat_ids = [chat_ids]
-
         if self.messages and len(self.messages) >= 5:
-            logger.warning(f'Too large, send a pure link message instead: "{self.title}"')
-            pure_link_post = Post(xml='', title=self.title, feed_title=self.feed_title,
-                                  link=self.link, author=self.author, telegraph_url=self.link)
-            await pure_link_post.send_message(chat_ids, reply_to_msg_id)
+            logger.debug(f'Too large, send a pure link message instead: "{self.title}"')
+            pure_link_post = Post(xml='', title=self.title, feed_title=self.feed_title, link=self.link,
+                                  author=self.author, telegraph_url=self.link, feed_link=self.feed_link)
+            await pure_link_post.send_message(chat_id, reply_to_msg_id, silent)
             return
 
-        while len(chat_ids) >= 1:
-            chat_id = chat_ids[0]
-            for msg in self.messages:
-                try:
-                    await msg.send(chat_id, reply_to_msg_id)
-
-                # errors caused by invalid img/video(s)
-                except (PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoInvalidError,
-                        PhotoCropSizeSmallError, PhotoContentUrlEmptyError, PhotoContentTypeInvalidError,
-                        GroupedMediaInvalidError, MediaGroupedInvalidError, MediaInvalidError,
-                        VideoContentTypeInvalidError, VideoFileInvalidError) as e:
-                    logger.warning(f'All media was set invalid because some of them are invalid '
-                                   f'({e.__class__.__name__}: {str(e)})')
-                    self.invalidate_all_media()
+        tries = 0
+        file_reference_expired_flag = False
+        e = None  # placeholder
+        while True:
+            if tries >= 5:
+                logger.error(f'Sending {self.link} failed after {tries} tries'
+                             f'{", w/ `FileReferenceError` occurred" * file_reference_expired_flag}. '
+                             f'Sometime it means that there may be some bugs in the code :(', exc_info=e)
+                break
+            tries += 1
+
+            try:
+                for msg in self.messages:
+                    await msg.send(chat_id, reply_to_msg_id, silent)
+                break
+
+            # errors caused by invalid img/video(s)
+            except (PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoInvalidError,
+                    PhotoCropSizeSmallError, PhotoContentUrlEmptyError, PhotoContentTypeInvalidError,
+                    GroupedMediaInvalidError, MediaGroupedInvalidError, MediaInvalidError,
+                    VideoContentTypeInvalidError, VideoFileInvalidError, ExternalUrlInvalidError) as err:
+                e = err
+                if self.invalidate_all_media():
+                    logger.debug(f'All media was set invalid because some of them are invalid '
+                                 f'({e.__class__.__name__}: {str(e)})')
                     await self.generate_message()
-                    await self.send_message(chat_ids)
-                    return
-
-                # errors caused by server instability or network instability between img server and telegram server
-                except (WebpageCurlFailedError, WebpageMediaEmptyError, MediaEmptyError) as e:
-                    if self.media.change_all_server():
-                        logger.info(f'Telegram cannot fetch some media ({e.__class__.__name__}). '
-                                    f'Changed img server and retrying...')
-                        await self.send_message(chat_ids)
-                        return
-                    logger.warning('All media was set invalid '
-                                   'because Telegram still cannot fetch some media after changing img server.')
-                    self.invalidate_all_media()
-                    await self.generate_message()
-                    await self.send_message(chat_ids)
-                    return
+                continue
 
-                except Exception as e:
-                    logger.warning(f'Sending {self.link} failed: ', exc_info=e)
-                    error_message = Post('Something went wrong while sending this message. Please check:<br><br>' +
-                                         traceback.format_exc().replace('\n', '<br>'),
-                                         self.title, self.feed_title, self.link, self.author, service_msg=True)
-                    await error_message.send_message(env.MANAGER)
+            except (UserIsBlockedError, UserIdInvalidError, ChatWriteForbiddenError, ChannelPrivateError) as e:
+                raise e  # let monitoring task to deal with it
+
+            # errors caused by server instability or network instability between img server and telegram server
+            except (WebpageCurlFailedError, WebpageMediaEmptyError, MediaEmptyError) as err:
+                e = err
+                if await self.media.change_all_server():
+                    logger.debug(f'Telegram cannot fetch some media ({e.__class__.__name__}). '
+                                 f'Changed img server and retrying...')
+                if self.invalidate_all_media():
+                    logger.debug('All media was set invalid '
+                                 'because Telegram still cannot fetch some media after changing img server.')
+                    await self.generate_message()
+                continue
 
-            chat_ids.pop(0)
+            except Exception as err:
+                e = err
+                if type(e) == FileReferenceExpiredError \
+                        or (type(e) == BadRequestError and fileReferenceNExpired.search(str(e))):
+                    file_reference_expired_flag = True
+                    continue
+                logger.warning(f'Sending {self.link} failed (feed: {self.feed_link}, user: {chat_id}): ', exc_info=e)
+                error_message = Post(f'Something went wrong while sending this message '
+                                     f'(feed: {self.feed_link}, user: {chat_id}). '
+                                     f'Please check:<br><br>' +
+                                     traceback.format_exc().replace('\n', '<br>'),
+                                     self.title, self.feed_title, self.link, self.author, feed_link=self.feed_link,
+                                     service_msg=True)
+                await error_message.send_message(env.MANAGER)
+                break
 
     async def telegraph_ify(self):
         try:
             telegraph_url = await tgraph.TelegraphIfy(self.xml, title=self.title, link=self.link,
                                                       feed_title=self.feed_title, author=self.author).telegraph_ify()
-            telegraph_post = Post(xml='', title=self.title, feed_title=self.feed_title,
-                                  link=self.link, author=self.author, telegraph_url=telegraph_url)
+            telegraph_post = Post(xml='', title=self.title, feed_title=self.feed_title, link=self.link,
+                                  author=self.author, telegraph_url=telegraph_url, feed_link=self.feed_link)
             return telegraph_post
         except exceptions.TelegraphError as e:
             if str(e) == 'CONTENT_TOO_BIG':
-                logger.warning(f'Content too big, send a pure link message instead: "{self.title}"')
-                pure_link_post = Post(xml='', title=self.title, feed_title=self.feed_title,
-                                      link=self.link, author=self.author, telegraph_url=self.link)
+                logger.debug(f'Content too big, send a pure link message instead: "{self.title}"')
+                pure_link_post = Post(xml='', title=self.title, feed_title=self.feed_title, link=self.link,
+                                      author=self.author, telegraph_url=self.link, feed_link=self.feed_link)
                 return pure_link_post
-            logger.warning('Telegraph API error: ' + str(e))
+            logger.debug('Telegraph API error: ' + str(e))
             return None
-        except (TimeoutError, asyncio.exceptions.TimeoutError):
-            logger.warning('Generate Telegraph post error: network timeout.')
+        except (TimeoutError, asyncio.TimeoutError):
+            logger.debug('Generate Telegraph post error: network timeout.')
             return None
         except (ClientError, ConnectionError) as e:
-            logger.warning(f'Generate Telegraph post error: network error ({e.__class__.__name__}).')
+            logger.debug(f'Generate Telegraph post error: network error ({e.__class__.__name__}).')
             return None
         except OverflowError:
-            logger.warning(f'Generate Telegraph post error: retried for too many times.')
+            logger.debug(f'Generate Telegraph post error: retried for too many times.')
             return None
         except Exception as e:
-            logger.warning('Generate Telegraph post error: ', exc_info=e)
+            logger.debug('Generate Telegraph post error: ', exc_info=e)
             return None
 
     def generate_pure_message(self):
@@ -224,11 +249,11 @@ async def generate_message(self, no_telegraph: bool = False) -> Optional[int]:
         if not no_telegraph and tgraph.apis and not self.service_msg and not self.telegraph_url \
                 and (len(self.soup.getText()) >= 4096
                      or (len(self.messages) if self.messages else await self.generate_message(no_telegraph=True)) >= 2):
-            logger.info(f'Will be sent via Telegraph: "{self.title}"')
+            logger.debug(f'Will be sent via Telegraph: "{self.title}"')
             self.telegraph_post = await self.telegraph_ify()  # telegraph post sent successful
             if self.telegraph_post:
                 return
-            logger.warning(f'Cannot be sent via Telegraph, fallback to normal message: "{self.title}"')
+            logger.debug(f'Cannot be sent via Telegraph, fallback to normal message: "{self.title}"')
 
         if not self.text:
             await self.generate_text()
@@ -278,10 +303,12 @@ async def generate_message(self, no_telegraph: bool = False) -> Optional[int]:
         return len(self.messages)
 
     def invalidate_all_media(self):
-        self.media.invalidate_all()
-        self.text = self.origin_text
+        if not self.media.invalidate_all():
+            return False
+        self.text = self.origin_text.copy()
         self._add_metadata()
         self._add_invalid_media()
+        return True
 
     def get_split_html(self, length_limit_head: int, head_count: int = -1, length_limit_tail: int = 4096):
         split_html = [stripNewline.sub('\n\n',
@@ -337,9 +364,10 @@ def _add_invalid_media(self):
             return
         self.text = Text([self.text, text_invalid_media])
 
-    async def _get_item(self, soup: Union[BeautifulSoup, Iterator, NavigableString], get_source: bool = False):
+    async def _get_item(self, soup: Union[PageElement, BeautifulSoup, Tag, NavigableString, Iterable[PageElement]],
+                        get_source: bool = False):
         result = []
-        if isinstance(soup, type(iter([]))):
+        if isinstance(soup, Iterator):  # a Tag is also Iterable, but we only expect an Iterator here
             for child in soup:
                 item = await self._get_item(child, get_source)
                 if item and get_source and isinstance(item, list):
@@ -352,10 +380,15 @@ async def _get_item(self, soup: Union[BeautifulSoup, Iterator, NavigableString],
                 return result
             return result[0] if len(result) == 1 else Text(result)
 
-        if type(soup) is NavigableString:
-            if str(soup) == ' ' or get_source:
-                return None
-            return Text(str(soup))
+        if isinstance(soup, NavigableString):
+            if type(soup) is NavigableString:
+                if str(soup) == ' ' or get_source:
+                    return None
+                return Text(str(soup))
+            return None  # we do not expect a subclass of NavigableString here
+
+        if not isinstance(soup, Tag):
+            return None
 
         tag = soup.name
 
@@ -480,13 +513,16 @@ async def _get_item(self, soup: Union[BeautifulSoup, Iterator, NavigableString],
             if not src.startswith('http'):
                 src = urljoin(self.feed_link, src)
             if not text:
+                # noinspection PyBroadException
                 try:
-                    page = await web.get(src)
-                    text = BeautifulSoup(page.decode(), 'lxml').title.text
+                    page = (await web.get(src, decode=True, semaphore=False)).content
+                    text = BeautifulSoup(page, 'lxml').title.text
+                except Exception:
+                    pass
                 finally:
                     if not text:
                         text = urlparse(src).netloc
-            return Link(f'iframe ({text})', param=src)
+            return Text([Br(2), Link(f'iframe ({text})', param=src), Br(2)])
 
         in_list = tag == 'ol' or tag == 'ul'
         for child in soup.children:
@@ -505,258 +541,3 @@ def __repr__(self):
 
     def __str__(self):
         return str(self.text)
-
-
-# --------------------------
-# Start various text classes
-# --------------------------
-class Text:
-    tag: Optional[str] = None
-    attr: Optional[str] = None
-
-    def __init__(self, content, param=None):
-        # type: (Union[Text, str, list], Optional[str]) -> None
-        self.param = param
-        if type(content) is type(self) or type(content) is Text:
-            self.content = content.content
-        elif type(content) is str:
-            self.content = content.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
-        else:
-            self.content = content
-
-    def is_nested(self):
-        return type(self.content) is not str
-
-    def is_listed(self):
-        return type(self.content) is list
-
-    def copy(self):
-        if not self.is_nested():
-            return self
-        return type(self)(self.content.copy(), param=self.param)
-
-    def strip(self, deeper: bool = False, strip_l: Optional[bool] = True, strip_r: Optional[bool] = True):
-        if not self.is_nested():  # str
-            if strip_l:
-                self.content.lstrip()
-            if strip_r:
-                self.content.rstrip()
-        if not self.is_listed():  # nested
-            if not deeper:
-                return
-            self.content.strip()
-        while strip_l and type(self.content[0]) is Br:
-            self.content.pop(0)
-        while strip_r and type(self.content[-1]) is Br:
-            self.content.pop()
-        if deeper:
-            any(map(lambda text: text.strip(strip_l=strip_l, strip_r=strip_r), self.content))
-
-    def lstrip(self, deeper: bool = False):
-        self.strip(deeper=deeper, strip_r=False)
-
-    def rstrip(self, deeper: bool = False):
-        self.strip(deeper=deeper, strip_l=False)
-
-    def get_html(self, plain: bool = False):
-        if self.is_listed():
-            result = ''
-            for subText in self.content:
-                result += subText.get_html(plain=plain)
-        elif self.is_nested():
-            result = self.content.get_html(plain=plain)
-        else:
-            result = self.content
-
-        if plain:
-            return result.replace('\n', '')
-
-        if self.attr and self.param:
-            return f'<{self.tag} {self.attr}="{self.param}">{result}</{self.tag}>'
-        if self.tag:
-            return f'<{self.tag}>{result}</{self.tag}>'
-        return result
-
-    def split_html(self, length_limit_head: int, head_count: int = -1, length_limit_tail: int = 4096) -> list:
-        split_list = []
-        # TODO: when result to be yield < length_limit*0.5, add subSubText to it
-        if type(self.content) == list:
-            curr_length = 0
-            subText = None
-            split_count = 0
-            result = ''
-            length = 0
-            for subText in self.content:
-                curr_length = len(subText)
-                curr_length_limit = length_limit_head if head_count == -1 or split_count < head_count \
-                    else length_limit_tail
-                if length + curr_length >= curr_length_limit and result:
-                    stripped = result.strip()
-                    result = ''
-                    length = 0
-                    if stripped:
-                        split_count += 1
-                        curr_length_limit = length_limit_head if head_count == -1 or split_count < head_count \
-                            else length_limit_tail
-                        split_list.append(stripped)  # split
-                if curr_length >= curr_length_limit:
-                    for subSubText in subText.split_html(curr_length_limit):
-                        split_count += 1
-                        split_list.append(subSubText)  # split
-                    continue
-                length += curr_length
-                result += subText.get_html()
-
-            curr_length_limit = length_limit_head if head_count == -1 or split_count < head_count \
-                else length_limit_tail
-            if length < curr_length_limit and result:
-                stripped = result.strip()
-                if stripped:
-                    split_list.append(stripped)  # split
-            elif curr_length >= curr_length_limit and subText:
-                for subSubText in subText.split_html(curr_length_limit):
-                    split_list.append(subSubText)  # split
-
-            return split_list
-
-        if type(self.content) == str:
-            result = self.content
-            if len(result) >= length_limit_head:
-                split_list = [result[i:i + length_limit_head - 1]
-                              for i in range(0, len(result), length_limit_head - 1)]  # split
-        else:  # nested
-            split_list = self.content.split_html(length_limit_head)  # split
-
-        return [f'<{self.tag} {self.attr}={self.param}>{text}</{self.tag}>' if self.attr and self.param
-                else (f'<{self.tag}>{text}</{self.tag}>' if self.tag
-                      else text)
-                for text in split_list]
-
-    def find_instances(self, _class, shallow: Optional[bool] = False) -> Optional[list]:
-        result = []
-        if isinstance(self, _class):
-            result.append(self)
-        if self.is_listed():
-            if shallow:
-                return [subText for subText in self.content if isinstance(subText, _class)]
-            for subText in self.content:
-                instance = subText.find_instances(_class)
-                if instance:
-                    result.extend(instance)
-            return result if result else None
-        if self.is_nested():
-            instance = self.content.find_instances(_class, shallow)
-            if instance:
-                result.extend(instance)
-        return result if result else None
-
-    def __len__(self):
-        length = 0
-        if type(self.content) == list:
-            for subText in self.content:
-                length += len(subText)
-            return length
-        return len(self.content)
-
-    def __bool__(self):
-        return bool(self.content)
-
-    def __eq__(self, other):
-        return type(self) == type(other) and self.content == other.content and self.param == other.param
-
-    def __repr__(self):
-        return f'{type(self).__name__}:{repr(self.content)}'
-
-    def __str__(self):
-        return self.get_html()
-
-
-class Link(Text):
-    tag = 'a'
-    attr = 'href'
-
-
-class Bold(Text):
-    tag = 'b'
-
-
-class Italic(Text):
-    tag = 'i'
-
-
-class Underline(Text):
-    tag = 'u'
-
-
-class Strike(Text):
-    tag = 's'
-
-
-class Code(Text):
-    tag = 'code'
-
-
-class Pre(Text):
-    tag = 'pre'
-
-
-class Br(Text):
-    def __init__(self, count: int = 1):
-        super().__init__('\n' * count)
-
-    def get_html(self, plain: bool = False):
-        if plain:
-            return ''
-        return super().get_html()
-
-
-class Hr(Text):
-    def __init__(self, content=None, param=None):
-        super().__init__('\n----------------------\n')
-
-    def get_html(self, plain: bool = False):
-        if plain:
-            return ''
-        return super().get_html()
-
-
-class ListItem(Text):
-    def __init__(self, content, param=None):
-        super().__init__(content)
-        nested_lists = self.find_instances(ListParent)
-        if not nested_lists:
-            return
-        for nested_list in nested_lists:
-            nested_list.rstrip()
-            nested_list_items = nested_list.find_instances(ListItem, shallow=True)
-            if not nested_list_items:
-                return
-            for nested_list_item in nested_list_items:
-                nested_list_item.content = [Text('    '), Text(nested_list_item.content)]
-            nested_list_items[-1].rstrip(deeper=True)
-
-
-class ListParent(Text):
-    pass
-
-
-class OrderedList(ListParent):
-    def __init__(self, content, param=None):
-        super().__init__(content)
-        list_items = self.find_instances(ListItem, shallow=True)
-        if not list_items:
-            return
-        index = 1
-        for list_item in list_items:
-            list_item.content = [Bold(f'{index}. '), Text(list_item.content), Br()]
-            index += 1
-
-
-class UnorderedList(ListParent):
-    def __init__(self, content, param=None):
-        super().__init__(content)
-        list_items = self.find_instances(ListItem, shallow=True)
-        if not list_items:
-            return
-        for list_item in list_items:
-            list_item.content = [Bold(f'● '), Text(list_item.content), Br()]
diff --git a/src/parsing/tgraph.py b/src/parsing/tgraph.py
index 0adb989279..98e63f1ce5 100644
--- a/src/parsing/tgraph.py
+++ b/src/parsing/tgraph.py
@@ -1,7 +1,9 @@
+from __future__ import annotations
+from typing import Union
+
 import asyncio
 import time
 import aiographfix as aiograph
-from typing import List, Union
 from bs4 import BeautifulSoup
 from aiohttp import ClientTimeout, ClientError
 from aiohttp_retry import RetryClient
@@ -51,13 +53,13 @@ async def flood_wait(self, retry_after: int):
 
 
 class APIs:
-    def __init__(self, tokens: Union[str, List[str]]):
+    def __init__(self, tokens: Union[str, list[str]]):
         if isinstance(tokens, str):
             tokens = [tokens]
         self.tokens = tokens
-        self._accounts: List[Telegraph] = []
+        self._accounts: list[Telegraph] = []
         self._curr_id = 0
-        asyncio.get_event_loop().run_until_complete(self.init())
+        env.loop.run_until_complete(self.init())
 
     async def init(self):
         for token in self.tokens:
@@ -101,7 +103,7 @@ def get_account(self) -> Telegraph:
 
 apis = None
 if env.TELEGRAPH_TOKEN:
-    apis = APIs(env.TELEGRAPH_TOKEN.split(','))
+    apis = APIs(env.TELEGRAPH_TOKEN)
     if not apis.valid:
         logger.error('Cannot set up Telegraph, fallback to non-Telegraph mode.')
         apis = None
@@ -157,7 +159,7 @@ async def telegraph_ify(self):
             raise OverflowError
 
         if self.retries >= 1:
-            logger.info('Retrying using another telegraph account...' if apis.count > 1 else 'Retrying...')
+            logger.debug('Retrying using another telegraph account...' if apis.count > 1 else 'Retrying...')
 
         telegraph_account = apis.get_account()
         try:
@@ -170,18 +172,18 @@ async def telegraph_ify(self):
             e_msg = str(e)
             if e_msg.startswith('FLOOD_WAIT_'):  # exceed flood control
                 retry_after = int(e_msg.split('_')[-1])
-                logger.warning(f'Flood control exceeded. Wait {retry_after}.0 seconds')
+                logger.debug(f'Flood control exceeded. Wait {retry_after}.0 seconds')
                 self.retries += 1
                 rets = await asyncio.gather(self.telegraph_ify(), telegraph_account.flood_wait(retry_after))
 
                 return rets[0]
             else:
                 raise e
-        except (TimeoutError, asyncio.exceptions.TimeoutError) as e:
+        except (TimeoutError, asyncio.TimeoutError) as e:
             raise e  # aiohttp_retry will retry automatically, so it means too many retries if caught
         except (ClientError, ConnectionError) as e:
             if self.retries < 3:
-                logger.warning(
+                logger.debug(
                     f'Network error ({e.__class__.__name__}) occurred when creating telegraph page, will retry')
                 return await self.telegraph_ify()
             raise e
diff --git a/src/web.py b/src/web.py
index 3f7c052801..3a2f474aba 100644
--- a/src/web.py
+++ b/src/web.py
@@ -1,41 +1,250 @@
+from __future__ import annotations
+from typing import Union, Optional, AnyStr
+from src.compat import nullcontext, ssl_create_default_context
+
 import asyncio
+import functools
+import aiodns
 import aiohttp
+import feedparser
+from concurrent.futures import ThreadPoolExecutor
 from aiohttp_socks import ProxyConnector
-from aiohttp_retry import RetryClient
-from typing import Union
+from aiohttp_retry import RetryClient, ExponentialRetry
+from ssl import SSLError
+from ipaddress import ip_network, ip_address
+from urllib.parse import urlparse
+from socket import AF_INET, AF_INET6
+from multidict import CIMultiDictProxy
+from attr import define
+
+from src import env, log, locks
+from src.i18n import i18n
+
+logger = log.getLogger('RSStT.web')
+
+_feedparser_thread_pool = ThreadPoolExecutor(1, 'feedparser_')
+_resolver = aiodns.DNSResolver(timeout=3, loop=env.loop)
+
+PROXY = env.R_PROXY.replace('socks5h', 'socks5').replace('sock4a', 'socks4') if env.R_PROXY else None
+PRIVATE_NETWORKS = tuple(ip_network(ip_block) for ip_block in
+                         ('127.0.0.0/8', '::1/128',  # loopback is not a private network, list in here for convenience
+                          '169.254.0.0/16', 'fe80::/10',  # link-local address
+                          '10.0.0.0/8',  # class A private network
+                          '172.16.0.0/12',  # class B private networks
+                          '192.168.0.0/16',  # class C private networks
+                          'fc00::/7',  # ULA
+                          ))
+
+HEADER_TEMPLATE = {
+    'User-Agent': env.USER_AGENT,
+    'Accept': '*/*',
+    'Accept-Encoding': 'gzip, deflate, br',
+}
+FEED_ACCEPT = 'application/rss+xml, application/rdf+xml, application/atom+xml, ' \
+              'application/xml;q=0.9, text/xml;q=0.8, text/*;q=0.7, application/*;q=0.6'
+
+EXCEPTIONS_SHOULD_RETRY = (asyncio.TimeoutError,
+                           # aiohttp.ClientPayloadError,
+                           # aiohttp.ClientResponseError,
+                           # aiohttp.ClientConnectionError,
+                           aiohttp.ServerConnectionError,
+                           TimeoutError)
+
+RETRY_OPTION = ExponentialRetry(attempts=2, start_timeout=1, exceptions=set(EXCEPTIONS_SHOULD_RETRY))
 
-from src import env
 
-_proxy = env.R_PROXY.replace('socks5h', 'socks5').replace('sock4a', 'socks4') if env.R_PROXY else None
+@define
+class WebResponse:
+    url: str  # redirected url
+    content: Optional[AnyStr]
+    headers: CIMultiDictProxy[str]
+    status: int
+    reason: Optional[str]
 
-_semaphore = asyncio.BoundedSemaphore(5)
 
+@define
+class WebFeed:
+    url: str  # redirected url
+    headers: Optional[CIMultiDictProxy[str]] = None
+    status: int = -1
+    reason: Optional[str] = None
+    rss_d: Optional[feedparser.FeedParserDict] = None
+    msg: Optional[str] = None
 
-async def get(url: str, timeout: int = None, semaphore: Union[bool, asyncio.Semaphore] = None) -> bytes:
+
+def proxy_filter(url: str, parse: bool = True) -> bool:
+    if not (env.PROXY_BYPASS_PRIVATE or env.PROXY_BYPASS_DOMAINS):
+        return True
+
+    hostname = urlparse(url).hostname if parse else url
+    if env.PROXY_BYPASS_PRIVATE:
+        try:
+            ip_a = ip_address(hostname)
+            is_private = any(ip_a in network for network in PRIVATE_NETWORKS)
+            if is_private:
+                return False
+        except ValueError:
+            pass  # not an IP, continue
+    if env.PROXY_BYPASS_DOMAINS:
+        is_bypassed = any(hostname.endswith(domain) and (hostname == domain or hostname[-len(domain) - 1] == '.')
+                          for domain in env.PROXY_BYPASS_DOMAINS)
+        if is_bypassed:
+            return False
+    return True
+
+
+async def get(url: str, timeout: Optional[float] = None, semaphore: Union[bool, asyncio.Semaphore] = None,
+              headers: Optional[dict] = None, decode: bool = False, no_body: bool = False) -> WebResponse:
+    """
+    :param url: URL to fetch
+    :param timeout: timeout in seconds
+    :param semaphore: semaphore to use for limiting concurrent connections
+    :param headers: headers to use
+    :param decode: whether to decode the response body
+    :param no_body: whether to return the response headers only
+    :return: {url, content, headers, status}
+    """
     if not timeout:
         timeout = 12
+    wait_for_timeout = (timeout * 2 + 5) * (2 if env.IPV6_PRIOR else 1)
+    return await asyncio.wait_for(_get(url, timeout, semaphore, headers, decode, no_body), wait_for_timeout)
 
-    proxy_connector = ProxyConnector.from_url(_proxy) if _proxy else None
-
-    await _semaphore.acquire() if semaphore is None or semaphore is True else \
-        await semaphore.acquire() if semaphore else None
 
+async def _get(url: str, timeout: Optional[float] = None, semaphore: Union[bool, asyncio.Semaphore] = None,
+               headers: Optional[dict] = None, decode: bool = False, no_body: bool = False) -> WebResponse:
+    host = urlparse(url).hostname
+    semaphore_to_use = locks.hostname_semaphore(host, parse=False) if semaphore in (None, True) \
+        else (semaphore or nullcontext())
+    v6_address = None
     try:
-        async with RetryClient(connector=proxy_connector, timeout=aiohttp.ClientTimeout(total=timeout),
-                               headers=env.REQUESTS_HEADERS) as session:
-            async with session.get(url) as response:
-                return await response.read()
-    finally:
-        _semaphore.release() if semaphore is None or semaphore is True else \
-            semaphore.release() if semaphore else None
-
-async def get_session(timeout: int = None):
+        v6_address = await _resolver.query(host, 'AAAA') if env.IPV6_PRIOR else None
+    except aiodns.error.DNSError:
+        pass
+    except Exception as e:
+        logger.debug(f'Error occurred when querying {url} AAAA:', exc_info=e)
+    socket_family = AF_INET6 if v6_address else 0
+
+    _headers = HEADER_TEMPLATE.copy()
+    if headers:
+        _headers.update(headers)
+
+    tries = 0
+    retry_in_v4_flag = False
+    while True:
+        tries += 1
+        assert tries <= 2, 'Too many tries'
+
+        if retry_in_v4_flag:
+            socket_family = AF_INET
+        ssl_context = ssl_create_default_context()
+        proxy_connector = (
+            ProxyConnector.from_url(PROXY, family=socket_family, ssl=ssl_context)
+            if (PROXY and proxy_filter(host, parse=False))
+            else aiohttp.TCPConnector(family=socket_family, ssl=ssl_context)
+        )
+
+        try:
+            async with locks.overall_web_semaphore:
+                async with semaphore_to_use:
+                    async with RetryClient(retry_options=RETRY_OPTION, connector=proxy_connector,
+                                           timeout=aiohttp.ClientTimeout(total=timeout), headers=_headers) as session:
+                        async with session.get(url) as response:
+                            status = response.status
+                            content = (await (response.text() if decode else response.read())
+                                       if status == 200 and not no_body
+                                       else None)
+                            if status in (403, 429, 451) and socket_family == AF_INET6 and tries == 1:
+                                retry_in_v4_flag = True
+                                continue
+                            return WebResponse(url=url,
+                                               content=content,
+                                               headers=response.headers,
+                                               status=status,
+                                               reason=response.reason)
+        except EXCEPTIONS_SHOULD_RETRY as e:
+            if socket_family != AF_INET6 or tries > 1:
+                raise e
+            err_msg = str(e).strip()
+            logger.debug(f'Fetch failed ({e.__class__.__name__}' + (f': {err_msg}' if err_msg else '')
+                         + f') using IPv6, retrying using IPv4: {url}')
+            retry_in_v4_flag = True
+            continue
+
+
+async def get_session(timeout: Optional[float] = None):
     if not timeout:
         timeout = 12
 
-    proxy_connector = ProxyConnector.from_url(_proxy) if _proxy else None
+    proxy_connector = ProxyConnector.from_url(PROXY) if PROXY else None
 
-    session = RetryClient(connector=proxy_connector, timeout=aiohttp.ClientTimeout(total=timeout),
-                          headers=env.REQUESTS_HEADERS)
+    session = RetryClient(retry_options=RETRY_OPTION, connector=proxy_connector,
+                          timeout=aiohttp.ClientTimeout(total=timeout), headers={'User-Agent': env.USER_AGENT})
 
     return session
+
+
+async def feed_get(url: str, timeout: Optional[float] = None, web_semaphore: Union[bool, asyncio.Semaphore] = None,
+                   headers: Optional[dict] = None, lang: Optional[str] = None, verbose: bool = True) -> WebFeed:
+    ret = WebFeed(url=url)
+
+    auto_warning = logger.warning if verbose else logger.debug
+    _headers = {}
+    if headers:
+        _headers.update(headers)
+    if 'Accept' not in _headers:
+        _headers['Accept'] = FEED_ACCEPT
+
+    try:
+        resp = await get(url, timeout, web_semaphore, headers=_headers)
+        rss_content = resp.content
+        ret.url = resp.url
+        ret.headers = resp.headers
+        ret.status = resp.status
+
+        # some rss feed implement http caching improperly :(
+        if resp.status == 200 and int(resp.headers.get('Content-Length', '1')) == 0:
+            ret.status = 304
+            ret.msg = f'"Content-Length" is 0'
+            return ret
+
+        if resp.status == 304:
+            ret.msg = f'304 Not Modified'
+            return ret  # 304 Not Modified, feed not updated
+
+        if rss_content is None:
+            status_caption = f'{resp.status}' + f' {resp.reason}' if resp.reason else ''
+            auto_warning(f'Fetch failed (status code error, {status_caption}): {url}')
+            ret.msg = f'ERROR: {i18n[lang]["status_code_error"]} ({status_caption})'
+            return ret
+
+        if len(rss_content) <= 524288:
+            rss_d = feedparser.parse(rss_content, sanitize_html=False)
+        else:  # feed too large, run in another thread to avoid blocking the bot
+            rss_d = await asyncio.get_event_loop().run_in_executor(_feedparser_thread_pool,
+                                                                   functools.partial(feedparser.parse,
+                                                                                     rss_content,
+                                                                                     sanitize_html=False))
+
+        if 'title' not in rss_d.feed:
+            auto_warning(f'Fetch failed (feed invalid): {url}')
+            ret.msg = 'ERROR: ' + i18n[lang]['feed_invalid']
+            return ret
+
+        ret.rss_d = rss_d
+    except aiohttp.InvalidURL:
+        auto_warning(f'Fetch failed (URL invalid): {url}')
+        ret.msg = 'ERROR: ' + i18n[lang]['url_invalid']
+    except (asyncio.TimeoutError,
+            aiohttp.ClientError,
+            SSLError,
+            OSError,
+            ConnectionError,
+            TimeoutError) as e:
+        err_name = e.__class__.__name__
+        auto_warning(f'Fetch failed (network error, {err_name}): {url}')
+        ret.msg = f'ERROR: {i18n[lang]["network_error"]} ({err_name})'
+    except Exception as e:
+        auto_warning(f'Fetch failed: {url}', exc_info=e)
+        ret.msg = 'ERROR: ' + i18n[lang]['internal_error']
+
+    return ret
diff --git a/telegramRSSbot.py b/telegramRSSbot.py
index 8e0901ff19..99a9c73d9c 100644
--- a/telegramRSSbot.py
+++ b/telegramRSSbot.py
@@ -1,340 +1,182 @@
 import asyncio
-import re
+
+try:
+    import uvloop
+
+    uvloop.install()
+except ImportError:  # uvloop do not support Windows
+    uvloop = None
+
+from functools import partial
 from time import sleep
+from typing import Optional
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from telethon import TelegramClient, events
 from telethon.errors import ApiIdPublishedFloodError
-from telethon.tl.custom import Message, Button
 from telethon.tl import types
-from telethon.tl.functions.channels import GetParticipantRequest
-from telethon.tl.functions.bots import SetBotCommandsRequest
-from re import compile as re_compile
-from typing import Optional, Union
-from datetime import datetime
-from functools import wraps, partial
 from random import sample
 from pathlib import Path
 
-from src import env, log
+from src import env, log, db, command
+from src.i18n import i18n, ALL_LANGUAGES
 from src.parsing import tgraph
-from src.feed import Feed, Feeds
-from src.parsing.post import Post
 
 # log
 logger = log.getLogger('RSStT')
 
-# global var placeholder
-feeds: Optional[Feeds] = None
-conflictCount = 0
-
-# permission verification
-ANONYMOUS_ADMIN = 1087968824
-
-# parser
-commandParser = re_compile(r'\s')
-
 # initializing bot
+loop = env.loop
+
 Path("config").mkdir(parents=True, exist_ok=True)
-bot = None
+bot: Optional[TelegramClient] = None
 if not env.API_ID or not env.API_HASH:
-    _use_sample_api = True
     logger.info('API_ID and/or API_HASH not set, use sample APIs instead. API_ID_PUBLISHED_FLOOD_ERROR may occur.')
-    API_IDs = sample(tuple(env.SAMPLE_APIS.keys()), len(env.SAMPLE_APIS))
-    sleep_for = 0
-    while API_IDs:
-        sleep_for += 10
-        API_ID = API_IDs.pop()
-        API_HASH = env.SAMPLE_APIS[API_ID]
-        try:
-            bot = TelegramClient('config/bot', API_ID, API_HASH, proxy=env.TELEGRAM_PROXY_DICT, request_retries=3) \
-                .start(bot_token=env.TOKEN)
-            break
-        except ApiIdPublishedFloodError:
-            logger.warning(f'API_ID_PUBLISHED_FLOOD_ERROR occurred. Sleep for {sleep_for}s and retry.')
-            sleep(sleep_for)
-
+    API_KEYs = {api_id: env.SAMPLE_APIS[api_id]
+                for api_id in sample(tuple(env.SAMPLE_APIS.keys()), len(env.SAMPLE_APIS))}
 else:
-    _use_sample_api = False
-    bot = TelegramClient('config/bot', env.API_ID, env.API_HASH, proxy=env.TELEGRAM_PROXY_DICT, request_retries=3) \
-        .start(bot_token=env.TOKEN)
+    API_KEYs = {env.API_ID: env.API_HASH}
+
+sleep_for = 0
+while API_KEYs:
+    sleep_for += 10
+    API_ID, API_HASH = API_KEYs.popitem()
+    try:
+        bot = TelegramClient('config/bot', API_ID, API_HASH, proxy=env.TELEGRAM_PROXY_DICT, request_retries=2,
+                             raise_last_call_error=True, loop=loop).start(bot_token=env.TOKEN)
+        break
+    except ApiIdPublishedFloodError:
+        if not API_KEYs:
+            logger.warning(f'API_ID_PUBLISHED_FLOOD_ERROR occurred.')
+            break
+        logger.warning(f'API_ID_PUBLISHED_FLOOD_ERROR occurred. Sleep for {sleep_for}s and retry.')
+        sleep(sleep_for)
 
 if bot is None:
     logger.critical('LOGIN FAILED!')
     exit(1)
 
 env.bot = bot
-bot_peer: types.InputPeerUser = asyncio.get_event_loop().run_until_complete(bot.get_me(input_peer=True))
-env.bot_id = bot_peer.user_id
-
-
-def permission_required(func=None, *, only_manager=False, only_in_private_chat=False):
-    if func is None:
-        return partial(permission_required, only_manager=only_manager,
-                       only_in_private_chat=only_in_private_chat)
-
-    @wraps(func)
-    async def wrapper(event: Union[events.NewMessage.Event, Message], *args, **kwargs):
-        command = event.text if event.text else '(no command, file message)'
-        sender_id = event.sender_id
-        sender: Optional[types.User] = await event.get_sender()
-        sender_fullname = sender.first_name + (f' {sender.last_name}' if sender.last_name else '')
-
-        if only_manager and sender_id != env.MANAGER:
-            await event.respond('此命令只可由机器人的管理员使用。\n'
-                                'This command can be only used by the bot manager.')
-            logger.info(f'Refused {sender_fullname} ({sender_id}) to use {command}.')
-            return
-
-        if event.is_private:
-            logger.info(f'Allowed {sender_fullname} ({sender_id}) to use {command}.')
-            return await func(event, *args, **kwargs)
-
-        if event.is_group:
-            chat: types.Chat = await event.get_chat()
-            input_chat: types.InputChannel = await event.get_input_chat()  # supergroup is a special form of channel
-            if only_in_private_chat:
-                await event.respond('此命令不允许在群聊中使用。\n'
-                                    'This command can not be used in a group.')
-                logger.info(f'Refused {sender_fullname} ({sender_id}) to use {command} in '
-                            f'{chat.title} ({chat.id}).')
-                return
-
-            input_sender = await event.get_input_sender()
-
-            if sender_id != ANONYMOUS_ADMIN:
-                participant: types.channels.ChannelParticipant = await bot(
-                    GetParticipantRequest(input_chat, input_sender))
-                is_admin = (isinstance(participant.participant, types.ChannelParticipantAdmin)
-                            or isinstance(participant.participant, types.ChannelParticipantCreator))
-                participant_type = type(participant.participant).__name__
-            else:
-                is_admin = True
-                participant_type = 'AnonymousAdmin'
-
-            if not is_admin:
-                await event.respond('此命令只可由群管理员使用。\n'
-                                    'This command can be only used by an administrator.')
-                logger.info(
-                    f'Refused {sender_fullname} ({sender_id}, {participant_type}) to use {command} '
-                    f'in {chat.title} ({chat.id}).')
-                return
-            logger.info(
-                f'Allowed {sender_fullname} ({sender_id}, {participant_type}) to use {command} '
-                f'in {chat.title} ({chat.id}).')
-            return await func(event, *args, **kwargs)
-        return
-
-    return wrapper
-
-
-@bot.on(events.NewMessage(pattern='/list'))
-@permission_required(only_manager=True)
-async def cmd_list(event: Union[events.NewMessage.Event, Message]):
-    list_result = '<br>'.join(f'<a href="{feed.link}">{feed.name}</a>' for feed in feeds)
-    if not list_result:
-        await event.respond('数据库为空')
-        return
-    result_post = Post('<b><u>订阅列表</u></b><br><br>' + list_result, plain=True, service_msg=True)
-    await result_post.send_message(event.chat_id, event.id if not event.is_private else None)
-
-
-@bot.on(events.NewMessage(pattern='/add'))
-@permission_required(only_manager=True)
-async def cmd_add(event: Union[events.NewMessage.Event, Message]):
-    args = commandParser.split(event.text)
-    if len(args) < 3:
-        await event.respond('ERROR: 格式需要为: /add 标题 RSS')
-        return
-    title = args[1]
-    url = args[2]
-    if await feeds.add_feed(name=title, link=url, uid=event.chat_id):
-        await event.respond('已添加 \n标题: %s\nRSS 源: %s' % (title, url))
-
-
-@bot.on(events.NewMessage(pattern='/remove'))
-@permission_required(only_manager=True)
-async def cmd_remove(event: Union[events.NewMessage.Event, Message]):
-    args = commandParser.split(event.text)
-    if len(args) < 2:
-        await event.respond("ERROR: 请指定订阅名")
-        return
-    name = args[1]
-    if feeds.del_feed(name):
-        await event.respond("已移除: " + name)
-        return
-    await event.respond("ERROR: 未能找到这个订阅名: " + name)
-
-
-@bot.on(events.NewMessage(pattern='/help|/start'))
-@permission_required(only_manager=True)
-async def cmd_help(event: Union[events.NewMessage.Event, Message]):
-    await event.respond(
-        "<a href='https://github.com/Rongronggg9/RSS-to-Telegram-Bot'>"
-        "RSS to Telegram bot，专为短动态类消息设计的 RSS Bot。</a>\n\n"
-        f"成功添加一个 RSS 源后, 机器人就会开始检查订阅，每 {env.DELAY} 秒一次。 (可修改)\n\n"
-        "标题为只是为管理 RSS 源而设的，可随意选取，但不可有空格。\n\n"
-        "命令:\n"
-        "<u><b>/add</b></u> <u><b>标题</b></u> <u><b>RSS</b></u> : 添加订阅\n"
-        "<u><b>/remove</b></u> <u><b>标题</b></u> : 移除订阅\n"
-        "<u><b>/list</b></u> : 列出数据库中的所有订阅\n"
-        "<u><b>/test</b></u> <u><b>RSS</b></u> <u><b>编号起点(可选)</b></u> <u><b>编号终点(可选)</b></u> : "
-        "从 RSS 源处获取一条 post (编号为 0-based, 不填或超出范围默认为 0，不填编号终点默认只获取一条 post)，"
-        "或者直接用 <code>all</code> 获取全部\n"
-        "<u><b>/import</b></u> : 导入订阅\n"
-        "<u><b>/export</b></u> : 导出订阅\n"
-        "<u><b>/version</b></u> : 查看版本\n"
-        "<u><b>/help</b></u> : 发送这条消息\n\n"
-        f"您的 chatid 是: {event.chat_id}",
-        parse_mode='html'
-    )
-
+env.bot_peer = loop.run_until_complete(bot.get_me(input_peer=False))
+env.bot_input_peer = loop.run_until_complete(bot.get_me(input_peer=True))
+env.bot_id = env.bot_peer.id
 
-@bot.on(events.NewMessage(pattern='/test'))
-@permission_required(only_manager=True)
-async def cmd_test(event: Union[events.NewMessage.Event, Message]):
-    args = commandParser.split(event.text)
-    if len(args) < 2:
-        await event.respond('ERROR: 格式需要为: /test RSS 条目编号起点(可选) 条目编号终点(可选)')
-        return
-    url = args[1]
 
-    if len(args) > 2 and args[2] == 'all':
-        start = 0
-        end = None
-    elif len(args) == 3:
-        start = int(args[2])
-        end = int(args[2]) + 1
-    elif len(args) == 4:
-        start = int(args[2])
-        end = int(args[3]) + 1
-    else:
-        start = 0
-        end = 1
-
-    try:
-        await Feed(link=url).send(event.chat_id, start, end, web_semaphore=False)
-    except Exception as e:
-        logger.warning(f"Sending failed:", exc_info=e)
-        await event.respond('ERROR: 内部错误')
-        return
-
-
-@bot.on(events.NewMessage(pattern='/import'))
-@permission_required(only_manager=True)
-async def cmd_import(event: Union[events.NewMessage.Event, Message]):
-    await event.respond('请发送需要导入的 OPML 文档',
-                        buttons=Button.force_reply())
-    # single_use=False, selective=Ture, placeholder='请发送需要导入的 OPML 文档'
-
-
-@bot.on(events.NewMessage(pattern='/export'))
-@permission_required(only_manager=True)
-async def cmd_export(event: Union[events.NewMessage.Event, Message]):
-    opml_file = feeds.export_opml()
-    if opml_file is None:
-        await event.respond('数据库为空')
-        return
-    await event.respond(file=opml_file,
-                        attributes=(types.DocumentAttributeFilename(
-                            f"RSStT_export_{datetime.utcnow().strftime('%Y%m%d%H%M%S')}.opml"),))
-
-
-class NewFileMessage(events.NewMessage):
-    def __init__(self, chats=None, *, blacklist_chats=False, func=None, incoming=None, outgoing=None, from_users=None,
-                 forwards=None, pattern=None, filename_pattern: str = None):
-        self.filename_pattern = re.compile(filename_pattern).match
-        super().__init__(chats, blacklist_chats=blacklist_chats, func=func, incoming=incoming, outgoing=outgoing,
-                         from_users=from_users, forwards=forwards, pattern=pattern)
-
-    def filter(self, event):
-        document: types.Document = event.message.document
-        if not document:
-            return
-        if self.filename_pattern:
-            filename = None
-            for attr in document.attributes:
-                if isinstance(attr, types.DocumentAttributeFilename):
-                    filename = attr.file_name
-                    break
-            if not self.filename_pattern(filename or ''):
-                return
-        return super().filter(event)
-
-
-@bot.on(NewFileMessage(filename_pattern=r'^.*\.opml$'))
-@permission_required(only_manager=True)
-async def opml_import(event: Union[events.NewMessage.Event, Message]):
-    reply_message: Message = await event.get_reply_message()
-    if not event.is_private and reply_message.sender_id != env.bot_id:
-        return
-    try:
-        opml_file = await event.download_media(file=bytes)
-    except Exception as e:
-        await event.reply('ERROR: 获取文件失败')
-        logger.warning(f'Failed to get opml file: ', exc_info=e)
-        return
-    await event.reply('正在处理中...\n'
-                      '如订阅较多或订阅所在的服务器太慢，将会处理较长时间，请耐心等待')
-    logger.info(f'Got an opml file.')
-    res = await feeds.import_opml(opml_file)
-    if res is None:
-        await event.reply('ERROR: 解析失败或文档不含订阅')
-        return
-
-    valid = res['valid']
-    invalid = res['invalid']
-    import_result = '<b><u>导入结果</u></b><br><br>' \
-                    + ('导入成功：<br>' if valid else '') \
-                    + '<br>'.join(f'<a href="{feed["link"]}">{feed["name"]}</a>' for feed in valid) \
-                    + ('<br><br>' if valid and invalid else '') \
-                    + ('导入失败：<br>' if invalid else '') \
-                    + '<br>'.join(f'<a href="{feed["link"]}">{feed["name"]}</a>' for feed in invalid)
-    result_post = Post(import_result, plain=True, service_msg=True)
-    await result_post.send_message(event.chat_id, event.message.id)
-
-
-@bot.on(events.NewMessage(pattern='/version'))
-@permission_required(only_manager=True)
-async def cmd_version(event: Union[events.NewMessage.Event, Message]):
-    await event.respond(env.VERSION)
-
-
-async def rss_monitor(fetch_all: bool = False):
-    await feeds.monitor(fetch_all)
-
-
-def main():
-    global feeds
+async def pre():
     logger.info(f"RSS-to-Telegram-Bot ({', '.join(env.VERSION.split())}) started!\n"
-                f"CHATID: {env.CHATID}\n"
                 f"MANAGER: {env.MANAGER}\n"
-                f"DELAY: {env.DELAY}s\n"
                 f"T_PROXY (for Telegram): {env.TELEGRAM_PROXY if env.TELEGRAM_PROXY else 'not set'}\n"
                 f"R_PROXY (for RSS): {env.REQUESTS_PROXIES['all'] if env.REQUESTS_PROXIES else 'not set'}\n"
-                f"DATABASE: {'Redis' if env.REDIS_HOST else 'Sqlite'}\n"
-                f"TELEGRAPH: {f'Enable ({tgraph.apis.count} accounts)' if tgraph.apis else 'Disable'}")
-
-    commands = [types.BotCommand(command="add", description="添加订阅"),
-                types.BotCommand(command="remove", description="移除订阅"),
-                types.BotCommand(command="list", description="列出所有订阅"),
-                types.BotCommand(command="test", description="测试"),
-                types.BotCommand(command="import", description="导入订阅"),
-                types.BotCommand(command="export", description="导出订阅"),
-                types.BotCommand(command="version", description="查看版本"),
-                types.BotCommand(command="help", description="查看帮助")]
-    try:
-        asyncio.get_event_loop().run_until_complete(
-            bot(SetBotCommandsRequest(scope=types.BotCommandScopeDefault(), lang_code='', commands=commands)))
+                f"DATABASE: {env.DATABASE_URL.split('://', 1)[0]}\n"
+                f"TELEGRAPH: {f'Enable ({tgraph.apis.count} accounts)' if tgraph.apis else 'Disable'}\n"
+                f"UVLOOP: {f'Enable' if uvloop is not None else 'Disable'}\n"
+                f"MULTIUSER: {f'Enable' if env.MULTIUSER else 'Disable'}")
+
+    await db.init()
+
+    # noinspection PyTypeChecker
+    manager_lang: Optional[str] = await db.User.get_or_none(id=env.MANAGER).values_list('lang', flat=True)
+
+    try:  # set bot command
+        await asyncio.gather(
+            command.utils.set_bot_commands(scope=types.BotCommandScopeDefault(), lang_code='',
+                                           commands=command.utils.get_commands_list()),
+            *(
+                command.utils.set_bot_commands(scope=types.BotCommandScopeDefault(),
+                                               lang_code=i18n[lang]['iso_639_code'],
+                                               commands=command.utils.get_commands_list(lang=lang))
+                for lang in ALL_LANGUAGES if len(i18n[lang]['iso_639_code']) == 2
+            ),
+            command.utils.set_bot_commands(scope=types.BotCommandScopePeer(types.InputPeerUser(env.MANAGER, 0)),
+                                           lang_code='',
+                                           commands=command.utils.get_commands_list(lang=manager_lang, manager=True)),
+        )
     except Exception as e:
         logger.warning('Set command error: ', exc_info=e)
 
-    feeds = Feeds()
-    scheduler = AsyncIOScheduler()
-    scheduler.add_job(rss_monitor, trigger='cron', minute='*/1', max_instances=5, timezone='utc')
+    # command handler
+    bot.add_event_handler(command.sub.cmd_sub,
+                          events.NewMessage(pattern='/add|/sub'))
+    bot.add_event_handler(command.sub.cmd_sub,
+                          command.utils.PrivateMessage(pattern=r'https?://'))
+    bot.add_event_handler(command.sub.cmd_sub,
+                          command.utils.ReplyMessage(pattern=r'https?://'))
+    bot.add_event_handler(command.sub.cmd_unsub,
+                          events.NewMessage(pattern='(/remove|/unsub)([^_]|$)'))
+    bot.add_event_handler(command.sub.cmd_unsub_all,
+                          events.NewMessage(pattern='/remove_all|/unsub_all'))
+    bot.add_event_handler(command.sub.cmd_list,
+                          events.NewMessage(pattern='/list'))
+    bot.add_event_handler(command.opml.cmd_import,
+                          events.NewMessage(pattern='/import'))
+    bot.add_event_handler(command.opml.cmd_export,
+                          events.NewMessage(pattern='/export'))
+    bot.add_event_handler(command.customization.cmd_set_or_callback_get_set_page,
+                          events.NewMessage(pattern='/set([^_]|$)'))
+    bot.add_event_handler(command.opml.opml_import,
+                          command.utils.NewFileMessage(filename_pattern=r'^.*\.opml$'))
+    bot.add_event_handler(command.management.cmd_start,
+                          events.NewMessage(pattern='/start'))
+    bot.add_event_handler(command.management.cmd_or_callback_help,
+                          events.NewMessage(pattern='/help'))
+    bot.add_event_handler(partial(command.customization.cmd_activate_or_deactivate_subs, activate=True),
+                          events.NewMessage(pattern='/activate_subs'))
+    bot.add_event_handler(partial(command.customization.cmd_activate_or_deactivate_subs, activate=False),
+                          events.NewMessage(pattern='/deactivate_subs'))
+    bot.add_event_handler(command.management.cmd_version,
+                          events.NewMessage(pattern='/version'))
+    bot.add_event_handler(command.management.cmd_lang,
+                          events.NewMessage(pattern='/lang'))
+    bot.add_event_handler(command.administration.cmd_test,
+                          events.NewMessage(pattern='/test'))
+    bot.add_event_handler(command.administration.cmd_set_option,
+                          events.NewMessage(pattern='/set_option'))
+    # callback query handler
+    bot.add_event_handler(command.sub.callback_unsub,
+                          events.CallbackQuery(pattern=r'^unsub_\d+(\|\d+)$'))
+    bot.add_event_handler(command.sub.callback_get_unsub_page,
+                          events.CallbackQuery(pattern=r'^get_unsub_page_\d+$'))
+    bot.add_event_handler(command.management.callback_set_lang,
+                          events.CallbackQuery(pattern=r'^set_lang_[\w_\-]+$'))
+    bot.add_event_handler(command.management.cmd_or_callback_help,
+                          events.CallbackQuery(pattern=r'^help$'))
+    bot.add_event_handler(partial(command.customization.callback_activate_or_deactivate_all_subs, activate=True),
+                          events.CallbackQuery(pattern=r'^activate_all_subs$'))
+    bot.add_event_handler(partial(command.customization.callback_activate_or_deactivate_all_subs, activate=False),
+                          events.CallbackQuery(pattern=r'^deactivate_all_subs$'))
+    bot.add_event_handler(partial(command.customization.callback_activate_or_deactivate_sub, activate=True),
+                          events.CallbackQuery(pattern=r'^activate_sub_\d+(\|\d+)$'))
+    bot.add_event_handler(partial(command.customization.callback_activate_or_deactivate_sub, activate=False),
+                          events.CallbackQuery(pattern=r'^deactivate_sub_\d+(\|\d+)$'))
+    bot.add_event_handler(partial(command.customization.callback_get_activate_or_deactivate_page, activate=True),
+                          events.CallbackQuery(pattern=r'^get_activate_page_\d+$'))
+    bot.add_event_handler(partial(command.customization.callback_get_activate_or_deactivate_page, activate=False),
+                          events.CallbackQuery(pattern=r'^get_deactivate_page_\d+$'))
+    bot.add_event_handler(command.customization.callback_set,
+                          events.CallbackQuery(pattern=r'^set(_\d+(_\w+(_\w+)?)?)?(\|\d+)?$'))
+    bot.add_event_handler(command.customization.cmd_set_or_callback_get_set_page,
+                          events.CallbackQuery(pattern=r'^get_set_page_\d+$'))
+    # being added to a group handler
+    bot.add_event_handler(command.management.cmd_start,
+                          command.utils.AddedToGroupAction())
+    bot.add_event_handler(command.management.cmd_start,
+                          command.utils.GroupMigratedAction())
+
+
+async def post():
+    await db.close()
+
+
+if __name__ == '__main__':
+    loop.run_until_complete(
+        pre()
+    )
+
+    scheduler = AsyncIOScheduler(event_loop=loop)
+    scheduler.add_job(command.monitor.run_monitor_task, trigger='cron', minute='*/1', max_instances=10, timezone='UTC')
     scheduler.start()
 
     bot.run_until_disconnected()
 
-
-if __name__ == '__main__':
-    main()
+    loop.run_until_complete(
+        post()
+    )