import logging
import time
import requests
from common import utils

DePoolCollectAddr  = "https://proxy.qg.net/replace"
DstPoolCollectAddr = "https://proxy.qg.net/extract"
DsnPoolCollectAddr = "https://proxy.qg.net/allocate"

class ProxyIP:
    def __init__(self, ip, serverAddr, deadline):
        self.ip = ip
        self.serverAddr = serverAddr
        self.deadline = deadline
        self.usable = True

    def markUnusable(self):
        self.usable = False

class IPPool:
    def __init__(self, url, logger):
        self.url = url
        self.ips = list()
        self.cursor = 0

        self.logger = logger

    def __delete__(self, ip):
        for i, p in enumerate(self.ips):
            if p != ip:
                continue
            self.ips.remove(ip)

    def collector(self):
        try:
            resp = requests.get(self.url).json()
        except Exception as e:
            return self.logger.exception("failed to collector resource: ", str(e))

        if resp["Code"] != 0:
            return self.logger.warning(resp["Msg"])

        ips = []
        for r in resp["Data"]:
            ip = ProxyIP(r['IP'], r['host'], r['deadline'])
            ips.append(ip)

        self.ips =ips
        self.cursor = 0

    def getIPs(self):
        return self.ips

    def next(self):
        global ip
        count = 0
        while True:
            try:
                ip = self.ips[self.cursor]
            except IndexError:
                continue
            self.cursor = (self.cursor+1)%len(self.ips)

            if utils.ConvertTimestamp(ip.deadline) - time.time() > 3 and ip.usable :
                break
            else:
                self.__delete__(ip)

            if count > len(self.ips):
                return
            count+=1
        return ip

    async def autoRefreshPool(self, interval):
        while True:
            time.sleep(interval)
            try:
                self.collector()
            except Exception as e :
                self.logger.exception("failed to auto refresh pool:", str(e))

def NewDynamicExclusiveIPPool(auth, cap):
    pool = IPPool(
        url= f"{DePoolCollectAddr}?Key={auth.key}&Pwd={auth.pwd}&Num={cap}",
        logger= logging.getLogger("DeIPPool")
    )
    pool.collector()
    return pool

def NewDynamicShareByNumIPPool(auth, cap):
    pool = IPPool(
        url= f"{DsnPoolCollectAddr}?Key={auth.key}&Pwd={auth.pwd}&Num={cap}",
        logger= logging.getLogger("DsnIPPool")
    )
    pool.collector()
    return pool

def NewDynamicShareByTimeIPPool(auth, cap):
    pool = IPPool(
        url= f"{DstPoolCollectAddr}?Key={auth.key}&Pwd={auth.pwd}&Num={cap}",
        logger= logging.getLogger("DeIPPool")
    )
    pool.collector()
    return pool