import random
import threading

from loguru import logger

import time

import requests
#
from models.device_info import DeviceInfo

from process.tools import split_phone_number


def get_code(phone, device_model):
    import requests

    url = "http://192.168.50.180:9696/login_code"
    json_data = {
        "phone": phone,
        "device_model": device_model

    }

    try:
        res = requests.post(url, json=json_data)
        code = res.json()["data"]["code"]
        return code
    except:
        pass

    return False


def get_socker_por():
    with open('socker5-ip.txt', 'r', encoding='utf-8') as f:
        content = f.read()

    tasks = []  # 创建任务列表
    lines = content.split('\n')

    por = random.choice(lines)
    # 解析代理信息
    proxy_parts = por.replace("socks5://", "").split(":")
    proxy_host = proxy_parts[0]
    proxy_port = int(proxy_parts[1])
    proxy_username = proxy_parts[2]
    proxy_password = proxy_parts[3]

    tg_phone_infos = TgPhoneDevices.select().where(
        TgPhoneDevices.addr == proxy_parts[0]
    )

    if len(tg_phone_infos) > 6:
        get_socker_por()

    return proxy_parts


def get_http_ip():
    with open('http-ip.txt', 'r', encoding='utf-8') as f:
        content = f.read()

    tasks = []  # 创建任务列表
    lines = content.split('\n')

    por = random.choice(lines)
    # 解析代理信息
    proxy_parts = por.replace("socks5://", "").split(":")
    proxy_host = proxy_parts[0]
    proxy_port = int(proxy_parts[1])

    tg_phone_infos = TgPhoneDevices.select().where(
        TgPhoneDevices.addr == proxy_parts[0]
    )

    if len(tg_phone_infos) > 6:
        get_socker_por()

    return proxy_parts


import os
import time
import asyncio

from loguru import logger
from opentele.api import API
from telethon import TelegramClient
from telethon.errors import SessionPasswordNeededError, PhoneCodeInvalidError, RPCError, PhoneNumberBannedError

from models.tg_phone_devices import TgPhoneDevices


async def get_device_info():
    """
    获取设备信息
    """

    NewApi = API.TelegramDesktop.Generate(system="windows")
    return {
        "api_id": NewApi.api_id,
        "api_hash": NewApi.api_hash,
        "device_model": NewApi.device_model,
        "system_version": NewApi.system_version,
        "app_version": NewApi.app_version,
        "lang_code": NewApi.lang_code,
        "system_lang_code": NewApi.system_lang_code
    }


async def create_telegram_client(server):
    """
    创建并配置 Telegram 客户端
    """
    PROXY_CONFIG = {
        'proxy_type': server.proxy_type,  # 或 'socks4'，具体看你的代理类型
        'addr': server.addr,  # 代理服务器地址
        'port': int(server.port),  # 代理服务器端口
        'username': server.user if server.user else "",  # 如果有用户名，填写
        'password': server.pwd if server.pwd else ""  # 如果有密码，填写
    }

    client = TelegramClient(
        fr"C:\sessions\{server.phone}",
        api_id=server.api_id,
        api_hash=server.api_hash,
        device_model=server.device_model,
        system_version=server.system_version,
        app_version=server.app_version,
        system_lang_code=server.system_lang_code,
        lang_code=server.lang_code,
        proxy=PROXY_CONFIG
    )
    return client


async def login_telegram(client, server, dev_info):
    """
    处理登录流程
    """
    try:
        sent_code_info = await client.send_code_request(server.phone)

        logger.info(f"账号：{server.phone}，发送验证码成功！！！")

        time.sleep(5)

        res = requests.get(f"http://192.168.50.180:9000/api/get_code?phone={dev_info.phone}")
        if res.status_code == 200:
            logger.info(f"账号：{server.phone}，获取验证码成功！！！")
        else:
            logger.error(f"账号：{server.phone}，获取验证码失败！！！")
            return

        code1 = res.json()["data"]["verification_code"]

        try:
            await client.sign_in(phone=server.phone, code=code1)
            logger.info(f"账号：{server.phone}，输入验证码成功》》》")

        except PhoneCodeInvalidError:
            logger.error(f"账号 {server.phone}，验证码无效，请重试")
            return 3
        except SessionPasswordNeededError:
            password = "Qasdasd123.0"
            if server.to_code:
                password = server.to_code
            await client.sign_in(password=password)

            logger.info(f"账号：{server.phone}，输入2fa成功》》》")

            server.code = password
            server.save()

        return 1
    except PhoneNumberBannedError:
        logger.error(f"账号 {server.phone}，已被封禁!!!")
        return 4

    except (RPCError, Exception) as e:
        logger.error(f'账号：{server.phone}，登录失败，错误信息：{e}')
        return 0


async def handle_login_failure(url, server):
    """
    处理登录失败的情况
    """

    time.sleep(5)

    session_file = fr"C:\sessions\{server.phone}.session"
    if os.path.exists(session_file):
        os.remove(session_file)
        print(f"文件 {session_file} 已删除")

    # 更新服务器信息
    server.area_code = server.area_code
    server.api_id = server.api_id
    server.api_hash = server.api_hash
    server.device_model = server.device_model
    server.system_version = server.system_version
    server.app_version = server.app_version
    server.system_lang_code = server.system_lang_code
    server.lang_code = server.lang_code
    server.phone = server.phone
    server.save()

    # 重新创建客户端并尝试登录
    client = await create_telegram_client(server)
    login_start = await login_telegram(client, url, server)

    if login_start == 1:
        me = await client.get_me()
        logger.info(f'账号 {server.phone} -- {me.first_name} 登录成功！')
        server.is_valid_session = "1"
        server.save()
    elif login_start == 0:
        logger.error("Telegram 登录失败")
        server.is_valid_session = "0"
        server.save()


async def main(_, country_code, local_number, semaphore, dev_info):
    # async with semaphore:

    device_info = await get_device_info()
    area_code = country_code
    phone_number = local_number

    server, created = TgPhoneDevices().get_or_create(
        phone=area_code + phone_number,
    )

    if server.is_valid_session:
        logger.info(f"第{_}，账号 {server.phone}，登录成功！！！")

        server.is_valid_session = 1
        server.save()

        return

    if server.is_valid_session is None:
        server.area_code = area_code
        server.phone_number = phone_number
        server.api_id = device_info["api_id"]
        server.api_hash = device_info["api_hash"]
        server.device_model = device_info["device_model"]
        server.system_version = device_info["system_version"]
        server.app_version = device_info["app_version"]
        server.system_lang_code = device_info["system_lang_code"]
        server.lang_code = device_info["lang_code"]
        server.phone = area_code + phone_number
        server.save()

    # 设置代理
    if not server.addr:
        pro_list = get_http_ip()

        server.proxy_type = "http"
        server.addr = pro_list[0]
        server.port = pro_list[1]

        # # 生成一个 0 到 1 之间的随机浮点数
        # random_num = random.random()
        #
        # # 判断随机数是否小于 0.5，如果小于 0.5，则表示概率为 50% 的事件发生
        # if random_num < 0.5:
        #     pro_list = get_http_ip()
        #
        #     server.proxy_type = "http"
        #     server.addr = pro_list[0]
        #     server.port = pro_list[1]
        #
        #
        # else:
        #     pro_list = get_socker_por()
        #
        #     server.proxy_type = "socks5"
        #     server.addr = pro_list[0]
        #     server.port = pro_list[1]
        #     server.user = pro_list[2]
        #     server.pwd = pro_list[3]

        server.save()

    logger.info(f"第{_}，账号：{server.phone}，开始登录。。。")

    time.sleep(random.randint(1, 10))

    try:
        client = await create_telegram_client(server)
        await client.connect()

        if await client.is_user_authorized():
            me = await client.get_me()
            logger.info(f'第{_}，账号：{server.phone} -- {me.first_name} 登录成功！')

            server.is_valid_session = 1
            server.save()

            await client.disconnect()
            return

        login_start = await login_telegram(client, server, dev_info)

        if login_start == 1:
            me = await client.get_me()
            logger.info(f'第{_}，账号 {server.phone} -- {me.first_name} 登录成功！')
            server.is_valid_session = "1"
            server.save()
        elif login_start == 0:
            logger.error(f"第{_}，账号 {server.phone}，Telegram 登录失败")
            server.is_valid_session = "0"
            server.save()
        elif login_start == 3:
            await client.disconnect()

            # await handle_login_failure(server)
        elif login_start == 4:
            server.is_valid_session = -1
            server.save()

        await client.disconnect()
    except:
        pass


def main2(_, a1, a2, a3, a5):
    asyncio.run(main(_, a1, a2, a3, a5))


async def main1():
    # 定义最大并发任务数
    max_concurrent_tasks = 10
    # 创建一个信号量对象
    semaphore = asyncio.Semaphore(max_concurrent_tasks)

    dev_infos = DeviceInfo.select().where(
        DeviceInfo.is_valid_session == 1,
    )

    tg_infos = TgPhoneDevices.select().where(
        TgPhoneDevices.is_valid_session == 1,
    )

    dev_phones = []
    for i in dev_infos:
        dev_phones.append(i.phone)

    tg_phones = []
    for i in tg_infos:
        tg_phones.append(i.phone)

    tasks = []
    for _, dev_info in enumerate(dev_infos):
        if dev_info.phone not in tg_phones:
            print(dev_info.phone)
            country_code, local_number = split_phone_number(phone_number=dev_info.phone)
            if country_code and local_number:
                threading.Thread(target=main2, args=(_, country_code, local_number, semaphore, dev_info,)).start()

                time.sleep(0.3)

    #             tasks.append(main(_, country_code, local_number, semaphore, dev_info))
    #
    # # 并发运行所有任务
    # await asyncio.gather(*tasks)


if __name__ == '__main__':
    asyncio.run(main1())