from PIL import Image, ImageDraw, ImageFont
import os
from tqdm import tqdm

# файл https://github.com/elkmovie/hsk30/charlist.txt проще 
# немного обработать вручную,удалив все заголовки и оставив 
# только 3000 знаков, ну и числа

file_path = "dictionaries/full_zi.txt"
glifs_folder = "glifs/"

# Используем PIL для рисования картинок
def drav_zi(han_zi):
    image = Image.new("RGB", (224, 224), "white")
    draw = ImageDraw.Draw(image)
# Изначально использовался этот шрифт, но в нем мало иероглифов
# за пределами HSK 3.0
    font = ImageFont.truetype("ZhuqueFangsong-Regular.ttf", 220)
    draw.text((2, 2), han_zi, (0, 0, 0), font=font)
    output_path = glifs_folder + han_zi + ".png"
    image.save(output_path)

os.makedirs(glifs_folder, exist_ok=True)

try:
    with open(file_path, 'r', encoding='utf-8') as file:
        for line in tqdm(file):
            # удаляем лишние пробелы
            line = line.strip()
            for char in line:
                # все что не иероглиф игнорируем
                # диапазон иероглифов в UTF-8
                if '\u4e00' <= char <= '\u9fff':  
                    drav_zi(char)
                    
# наличие перехватчика ошибок в таких странных местах как признак 
# того, что часть кода сгененрирована нейросетью
except FileNotFoundError:
    print("File not found.")
except Exception as e:
    print(f"Error: {e}")

import torch
import torch.nn.functional as F
from transformers import AutoModel, AutoImageProcessor
from PIL import Image
import os
import sqlite3
from typing import List
import struct
import numpy


# Для сохранения в реальной таблице
def serialize_f32(vector: List[float]) -> bytes:
    # перевод float в строку байт
    return struct.pack("%sf" % len(vector), *vector)


# передача изображения в cuda
def img_converion(img):
    # определяем количество каналов в изображении
    channel_count = len(img.getbands())
# ставим сначала каналы цветов изображения, что бы соответствовать 
# требованиям тензоров torch 
    img = numpy.reshape(img, (channel_count, img.height, img.width))
# непосредственно переводим тензор в формат  torch
    img = torch.from_numpy(img.astype(numpy.float32))
# и отправляем его на видеокарту
    img = img.cuda()
    return img


# Подготовка модели, выдающей эмбеддинги
model_ckpt = "nateraw/vit-base-beans"
processor = AutoImageProcessor.from_pretrained(model_ckpt)
vision_model = AutoModel.from_pretrained(model_ckpt)
vision_model.to('cuda')
# Путь к папке, откуда нужно взять файлы
folder_path = 'glifs'

# Открытие таблицы
conn = sqlite3.connect('nateraw_glifs.db')
cursor = conn.cursor()

# Создание таблицы для хранения эмбеддингов
cursor.execute('''
CREATE TABLE IF NOT EXISTS files (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    zi TEXT NOT NULL,
    embedding BLOB
)
''')

# Получение списка всех файлов в указанной папке
file_list = [os.path.join(folder_path, f) for f in os.listdir(folder_path)]

# Проход по всем файлам
with conn:
    for file_path in file_list:
# выделяем иероглиф из названия файла
        zi = file_path[6:7]
# открываем изображение 
        image = Image.open(file_path)
# отправляем его на видеокарту
        image = img_converion(image)
# получаем эмбеддинги согласно руководству hugginface 
        inputs = processor(image, return_tensors="pt")
        inputs.to('cuda')
        img_emb = vision_model(**inputs).last_hidden_state
        img_embeddings = F.normalize(img_emb[:, 0], p=2, dim=1)
# переводим вектор в последовательность байт
        item = serialize_f32(img_embeddings[0].tolist())
# и записываем все в базу
        conn.execute(
            "INSERT INTO files(zi, embedding) VALUES (?, ?)",
            (zi, item)
        )
conn.close()

import streamlit as st
import os
import signal
import numpy as np
import sqlite3
import struct
import sqlite_vec
from pynput.keyboard import Key, Controller

base_file = "nateraw_glifs.db"

# переводим строку байт обратно в вектора
def deserialize_f32(byte_string):
    # создаем пустой массив
    vec_count = len(byte_string)//4
    float_vector = np.empty(vec_count, dtype=np.float32)
    # берем каждые четыре байта и преобразуем их во float
    for i in range(vec_count):
        byte_block = byte_string[i*4:(i+1)*4]
        # для преобразования используем struct 
        float_value = struct.unpack('f', byte_block)[0]
        float_vector[i] = float_value
    return float_vector


# создаем виртуальную базу, только она работает с векторами
db = sqlite3.connect(":memory:")
db.enable_load_extension(True)
sqlite_vec.load(db)
db.enable_load_extension(False)
db.execute("CREATE VIRTUAL TABLE vec_items USING vec0(zi TEXT, embedding float[768])")

# открываем реальную базу
conn = sqlite3.connect(base_file)
cursor = conn.cursor()
# и считываем все записи
query = "SELECT * FROM files"
try:
    cursor.execute(query)
    rows = cursor.fetchall()
    # переносим все записи в виртуальную базу
    for row in rows:
        db.execute(
           "INSERT INTO vec_items(zi, embedding) VALUES (?, ?)",
           [row [1], row [2]],
        )
except sqlite3.Error as e:
    st.write("Request execution error:", e)
finally:
    conn.close()


# формируем окно
st.set_page_config(page_title="Поиск похожих иероглифов", layout="wide")
st.title("Поиск похожих иероглифов")

# на боковой панели кнока выхода
exit_app = st.sidebar.button("Shut Down")
if exit_app:
    # пытаемся закрыть текущую вкладку браузера
    keyboard = Controller()
    keyboard.press(Key.ctrl)
    keyboard.press('w')
    keyboard.release('w')
    keyboard.release(Key.ctrl)
    # Выключаем процесс streamlit
    os.kill(os.getpid(), signal.SIGKILL)

# Ввод иероглифа
col1, col2 = st.columns(2)
with col1:
    zi = st.text_input( "Введите иероглиф и нажмите Enter", "时", max_chars=1)
# TODO проверка что введен иероглиф
with col2:
    zi_count = st.number_input("Всего отобрать иероглифов:", value=20, min_value=1, max_value=100)
result = db.execute("SELECT embedding FROM vec_items WHERE zi=?", (zi,)).fetchone()
four_col = []
# Делаем две колонки, что бы взглядом можно было охватить больше
# иероглифов за раз
for row in rows:
    four_col.append(row [0])
    four_col.append(row [1])
# формируем резульаты в списки по 4, что бы выводить в две колонки
    if len(four_col) == 4:
	# делаем часть колонки с будущей словарной статьей пошире
        col1, col2, col3, col4 = st.columns([1, 10, 1, 10])
        with col1:
            prtbl = """<p style="font-size: 48px; font-family: 'ZhuqueFangsong-Regular.ttf';">""" + four_col[0]
            st.write(prtbl, unsafe_allow_html=True)
        with col2:
            st.write("Расстояние:", four_col[1])
            # TODO смысл и пиньинь
        with col3:
            prtbl = """<p style="font-size: 48px; font-family: 'ZhuqueFangsong-Regular.ttf';">""" + four_col[2]
            st.write(prtbl, unsafe_allow_html=True)
        with col4:
            st.write("Расстояние:", four_col[3])
          	# TODO смысл и пиньинь
        four_col = []

# если пользователь ввел нечетное число знаков для отбора 
# и отображения, последний надо показать в одной колонке
    elif len(four_col) == 2:
        col1, col2 = st.columns([1, 21])
        with col1:
            prtbl = """<p style="font-size: 48px; font-family: 'ZhuqueFangsong-Regular.ttf';">""" + four_col[0]
            st.write(prtbl, unsafe_allow_html=True)
        with col2:
            st.write("Расстояние:", four_col[1])
          # TODO смысл и пиньинь

import sqlite3
import os
from tqdm import tqdm

base_path = 'brks_clean.db'
nown_elements = []


# Выделение иероглифа(словарного слова) в html тегах
def zi_finder(text):
    # формат авторов словарей
    # перед иероглифом стоит ключевое слово headword
    start_index = text.find("headword")
    # а конец отмечается двумя разными тегами почему-то
    if (end_index := text.find("</big><br>")) == -1:
        end_index = text.index("</b><br>", start_index+9, )
    zi = text[start_index+10:end_index]
    return zi


# Отделение Пиньиня и остального текста
def pinyin_separation(text, pinyin_index):
    pinyin = text[:pinyin_index]
    article = text[pinyin_index:]
    return pinyin, article


# Наполнение промежуточных переменных и одновременная дозапись в базу
def base_filler(texts, conn):
    zi_values = []
    pinyin_values = []
    article_values = []
    for text in texts:
        # Если нашел строку с ироглифами
        if "<div id=" in text:
            zi = zi_finder(text)
            # и такое слово уже было
            # !NB это очень медленно под конец! не смог придумать 
            # ничего лучше в тот момент :(
            if zi in nown_elements:
                continue  # пропускаем его
            else:
                zi_values.append(zi)
                nown_elements.append(zi)
        # Если в строке есть словарная статья
        elif (pinyin_index := text.find("<p style=")) != -1:
            # ищем, где кончается пиньин
            pinyin, article = pinyin_separation(text, pinyin_index)
            pinyin_values.append(pinyin)
            article_values.append(article)
        # Прочие строки пропускаем
        else:
            continue
    # пишем все разом в базу
    if zi_values and pinyin_values and article_values:
        conn.executemany(
            "INSERT INTO brks (zi, pinyin, rus_articles) VALUES (?, ?, ?)",
            zip(zi_values, pinyin_values, article_values)
        )
        conn.commit()

# Создание таблицы
conn = sqlite3.connect(base_path)
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS brks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    zi TEXT NOT NULL,
    pinyin TEXT,
    rus_articles TEXT,
)
''')

# Все папки с html файлами словаря
adr_list = [f"dabkrs_{i}.hdir" for i in range(1, 4)]
# Идем по файлам
for folder_path in adr_list:
    file_list = [os.path.join(folder_path, f) for f in os.listdir(folder_path)]
    for item in tqdm(file_list):
        with open(item, 'r', encoding='utf-8') as file:
            texts = file.readlines()
            base_filler(texts, conn)

conn.close() 

import sqlite3
from tqdm import tqdm

conn = sqlite3.connect('brks.db')
cursor = conn.cursor()
# Получение всех уникальных zi
unique_zi_values = cursor.execute("SELECT zi FROM brks GROUP BY zi HAVING COUNT(*) > 1").fetchall()
print (len(unique_zi_values))
# Формирование списка zi для удаления
values_to_delete = [row[0] for row in unique_zi_values]
print (len(values_to_delete))
# Удалите повторяющихся значений в колонке zi, кроме первого из них
for zi in tqdm(values_to_delete):
    cursor.execute("DELETE FROM brks WHERE zi = ? AND id NOT IN (SELECT MIN(id) FROM brks WHERE zi = ?)", (zi, zi))
conn.commit()
conn.close()

import sqlite3
from tqdm import tqdm
import re


# удалем слеши по краям статьи и заменяем их на точки с запятой в середине
def art_clean(leftover):
    leftover = leftover.lstrip('')
    leftover = leftover.lstrip('/')
    leftover = leftover.rstrip('')
    leftover = leftover.rstrip('/')
    leftover = leftover.replace('/', ';')
    return leftover


# https://github.com/ProxPxD/Hanzi_searcher/blob/master/cedict_ts.u8
file_name = 'dictionaries/cedict_ts.u8'
db_name = 'eng_dict.db'

conn = sqlite3.connect(db_name)
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS eng_dict (
    zi TEXT,
    old_zi TEXT,
    pinyin TEXT,
    eng_art TEXT
)
''')
# переменные для одновременной вставки в базу
zi_s = []
old_zi_s = []
pinyin_s = []
eng_art_s = []

# читаем файл по строкам
with open(file_name, 'r') as file:
    for line in tqdm(file):
        # разделяем колонки
        zi, leftover = line.split(' ', 1)
	# это упрощенный иероглиф
        zi_s.append(zi)
        old_zi, leftover = leftover.split(' ', 1)
	# это классический иероглиф
        old_zi_s.append(old_zi)
        match = re.search(r'\[([^]]+)\]', leftover)
        if match:
            pinyin = match.group(1)
            # удаляем найденное из строки
            leftover = re.sub(r'\[([^]]+)\]', '', leftover)
            pinyin_s.append(pinyin)
        # очищаем словарную статью
        eng_art = art_clean(leftover)
        eng_art_s.append(eng_art)
    # записываем все разом в базу
    if zi_s and old_zi_s and pinyin_s and eng_art_s:
        conn.executemany(
            "INSERT INTO eng_dict (zi, old_zi, pinyin, eng_art) VALUES (?, ?, ?, ?)",
            zip(zi_s, old_zi_s, pinyin_s, eng_art_s)
        )
conn.commit()
conn.close()

import sqlite3
# открываем базу со соловарем
base_file = 'brks_clean.db'
conn = sqlite3.connect(base_file)
cursor = conn.cursor()
query = "SELECT zi FROM brks"
full_zi = []
# отбирем все слова вообще
try:
    cursor.execute(query)
    rows = cursor.fetchall()
except sqlite3.Error as e:
    print("Ошибка при выполнении запроса:", e)
finally:
    conn.close()
# если слово длиннее одного символа его игнорируем
for row in rows:
    if len(row [0]) > 1:
        continue
    else:
        full_zi.append (row [0])

import sys
# Проверяем, что при компиляции python был включен флаг 
# --enable-loadable-sqlite-extensions
try:
    import sqlite3
    db = sqlite3.connect(":memory:")
    db.enable_load_extension(True)
except AttributeError:
    import sqlean as sqlite3
    db = sqlite3.connect(":memory:")
    db.enable_load_extension(True)
import streamlit as st
import os
import sqlite_vec
import numpy as np
import struct
from pynput.keyboard import Key, Controller
import signal
import locale

# пытаемся найти русскую локаль
locale.setlocale(locale.LC_ALL, "")
locale_info = locale.getlocale()
user_lang = locale_info[0].split('_')[0]
lang_code = locale.normalize(user_lang)[:2].lower()

# Текстовые переменные
if lang_code == "ru":
    zi_title = "Поиск похожих иероглифов"
    zi_invit = "Введите иероглиф и нажмите Enter"
    base_error = "Ошибка при выполнении запроса:"
    find_eror = "Такой иероглиф не найде."
    find_count = "Всего отобрать иероглифов:"
    dist_text = """                Расстояние:"""
    turn_off = "Выход"
    radio_title = "Вид словарной статьи"
    ru_short_art = "Короткая русская"
    ru_full_art = "Длинная русская"
    eng_art = "Английская"
    embeding_radio_title = "Сортировать по эмбеддингам"
else:
    zi_title = "Search for similar hieroglyphs"
    zi_invit = "Type the hieroglyph and press Enter"
    base_error = "Request execution error:"
    find_eror = "The line with the specified hieroglyph was not found."
    find_count = "Total to select hieroglyphs:"
    dist_text = """                Distance:"""
    turn_off = "Shut Down"
    radio_title = "Type of dictionary entry"
    ru_short_art = "Short Russian"
    ru_full_art = "Long Russian"
    eng_art = "English"
    embeding_radio_title = "Sorting by embeddings"

timm_name = "Timm dino v2"
resnet_name = "ResNet50"
base_file = 'zi.db'
zi_style_set = """<p style="font-size: 60px; font-family: 'ZhuqueFangsong-Regular.ttf';">"""

# параметры окна
st.set_page_config(page_title=zi_title, layout="wide")


# переводим строку байт обратно в вектора
def deserialize_f32(byte_string):
    # создаем пустой массив
    vec_count = len(byte_string)//4
    float_vector = np.empty(vec_count, dtype=np.float32)
    # берем каждые четыре байта и преобразуем их во float
    for i in range(vec_count):
        byte_block = byte_string[i*4:(i+1)*4]
        # для преобразования используем struct 
        float_value = struct.unpack('f', byte_block)[0]
        float_vector[i] = float_value
    return float_vector


# создаем виртуальную базу, только она работает с векторами
sqlite_vec.load(db)
db.enable_load_extension(False)
db.execute("CREATE VIRTUAL TABLE vec_items USING vec0(zi TEXT, pinyin TEXT, ru_short_art TEXT, ru_full_art TEXT, eng_art TEXT, timm_embedding float[1024], res_embedding float[2048])")

# открываем реальную базу
conn = sqlite3.connect(base_file)
cursor = conn.cursor()
# и считываем все значения
query = "SELECT * FROM files"
try:
    cursor.execute(query)
    rows = cursor.fetchall()
    # переносим все в виртуальную базу
    for row in rows:
        db.execute(
           "INSERT INTO vec_items(zi, pinyin, ru_short_art, ru_full_art, eng_art, timm_embedding, res_embedding) VALUES (?, ?, ?, ?, ?, ?, ?)",
            [row [1], row [2], row [3], row[4], row[5], row[7], row[8]],
        )
# row [6] было зарезрвировано для признака HSK и здесь не используется
except sqlite3.Error as e:
    st.write(base_error, e)
finally:
    conn.close()

# интерфейс пользователя
st.title(zi_title)
# боковая панель
exit_app = st.sidebar.button(turn_off)
if exit_app:
    # Закрываем текущую вкладку браузера
    keyboard = Controller()
    keyboard.press(Key.ctrl)
    keyboard.press('w')
    keyboard.release('w')
    keyboard.release(Key.ctrl)
    # Останавливаем streamlit
    os.kill(os.getpid(), signal.SIGKILL)
st.sidebar.divider()
# выбор словарной статьи
type_select = st.sidebar.radio (label = radio_title, options = [ru_short_art, ru_full_art, eng_art])
st.sidebar.divider()
# выбор эмбеддингов
embeding_select = st.sidebar.radio (label = embeding_radio_title, options = [timm_name, resnet_name])

# элементы для ввода
col1, col2 = st.columns(2)
with col1:
    zi = st.text_input(zi_invit, "时", max_chars=1)
    # Диапазон иероглифов в utf-8
    if '\u4e00' >= zi >= '\u9fff':  
        zi = "时"
with col2:
    zi_count = st.number_input(find_count, value=50, min_value=1, max_value=100)
# задаем, какую статью показывать
if type_select == ru_short_art:
    d_type = "ru_short_art"
elif type_select == ru_full_art:
    d_type = "ru_full_art"
else:
    d_type = "eng_art"

# если выбраны эмбеддинги timm
if embeding_select == timm_name:
    result = db.execute("SELECT timm_embedding FROM vec_items WHERE zi=?", (zi,)).fetchone()
    if result:
        # Если иероглиф найден, получаем столько ближайших, сколько указал пользователь
        query = result[0]
        rows = db.execute("""SELECT zi, distance, pinyin, ru_short_art, ru_full_art, eng_art FROM vec_items WHERE timm_embedding MATCH ? ORDER BY distance LIMIT ?""", [deserialize_f32(query), zi_count],).fetchall()
    else:
        st.error(find_eror)
# если resnet
else:
    result = db.execute("SELECT res_embedding FROM vec_items WHERE zi=?", (zi,)).fetchone()
    if result:
        # аналогично отбираем. В процедуру объединить нельзя, sqlite3 не хочет принимать имя столбца через знак подстановки
        query = result[0]
        rows = db.execute("""SELECT zi, distance, pinyin, ru_short_art, ru_full_art, eng_art FROM vec_items WHERE res_embedding MATCH ? ORDER BY distance LIMIT ?""", [deserialize_f32(query), zi_count],).fetchall()
    else:
        st.error(find_eror)

# формируем отображение 
four_col = []
# формируем список для отображения в две колонки
for row in rows:
    four_col.append(row[0])
    four_col.append(row[1])
    four_col.append(row[2])
# выбираем, какую статью показывать
    if type_select == ru_short_art:
        four_col.append(row[3])
    elif type_select == ru_full_art:
        four_col.append(row[4])
    else:
        four_col.append(row[5])
    # two-column display
# Делаем две колонки, что бы взглядом можно было охватить больше иероглифов за раз    
if len(four_col) == 8:
        col1, col2, col3, col4 = st.columns([1, 10, 1, 10])
# здесь сам иероглиф
        with col1:
            prtbl = zi_style_set + four_col[0]
            st.write(prtbl, unsafe_allow_html=True)
# здесь статья, пиньин и удаленность
        with col2:
            st.write(four_col[2], dist_text, four_col[1], unsafe_allow_html=True)
            st.write(four_col[3], unsafe_allow_html=True)
# TODO сделать наполнение колонок в цикле, что бы их количество можно было менять
        with col3:
            prtbl = zi_style_set + four_col[4]
            st.write(prtbl, unsafe_allow_html=True)
        with col4:
            st.write(four_col[6], dist_text, four_col[5])
            st.write(four_col[7], unsafe_allow_html=True)
        four_col = []
# если пользователь ввел нечетное число знаков для отбора и отображения, последний надо показать в одной колонке
if len(four_col) == 4:
    col1, col2 = st.columns([1, 21])
    with col1:
        prtbl = zi_style_set + four_col[0]
        st.write(prtbl, unsafe_allow_html=True)
    with col2:
        st.write(four_col[2], dist_text, four_col[1])
        st.write(four_col[3], unsafe_allow_html=True)