# coding: utf-8
# -------------------------------------------------------------------
# YakPanel
# -------------------------------------------------------------------
# Copyright (c) 2015-2099 YakPanel(www.yakpanel.com) All rights reserved.
# -------------------------------------------------------------------
# Author: hwliang <hwl@yakpanel.com>
# -------------------------------------------------------------------

# ------------------------------
# HTTP代理模块
# ------------------------------

import os
import re
import socket
import time
from http.cookies import SimpleCookie

import requests
import urllib3.util.connection as urllib3_conn

from YakPanel import request, Response, public, app, get_phpmyadmin_dir, session


class HttpProxy:
    _pma_path = None

    @staticmethod
    def _err_resp(msg: str = None):
        return Response(
            msg or "something wrong with socket, please cheak and try again...", 500
        )

    def get_res_headers(self, p_res):
        """
            @name 获取响应头
            @author hwliang<2022-01-19>
            @param p_res<Response> requests响应对像
            @return dict
        """
        headers = {}
        for h in p_res.headers.keys():
            if h in ['content-encoding', 'Content-Encoding', 'transfer-encoding', 'Transfer-Encoding']:
                continue
            headers[h] = p_res.headers[h]
            if h in ['location', 'Location']:

                # ============  redirect ===================
                # phpmyadmin
                if headers[h].find('phpmyadmin_') != -1:
                    if not self._pma_path:
                        self._pma_path = get_phpmyadmin_dir()
                        if self._pma_path:
                            self._pma_path = self._pma_path[0]
                        else:
                            self._pma_path = ''
                    headers[h] = headers.get(h, "").replace(self._pma_path, 'phpmyadmin')
                # adminer
                elif headers[h].find("adminer_") != -1:
                    from adminer.manager import AdminerManager
                    adminer_dir, _ = AdminerManager().adminer_dir_port
                    headers[h] = headers.get(h, "").replace(adminer_dir, 'adminer')
                # ============  redirect end ==================

                if headers[h].find('127.0.0.1') != -1:
                    headers[h] = re.sub(r"https?://127.0.0.1(:\d+)?/", request.url_root, headers[h])
                if request.url_root.find('https://') == 0:
                    headers[h] = headers.get(h, '').replace('http://', 'https://')
        return headers

    def set_res_headers(self, res, p_res):
        """
            @name 设置响应头
            @author hwliang<2022-01-19>
            @param res<Response> flask响应对像
            @param p_res<Response> requests响应对像
            @return res<Response>
        """
        # from datetime import datetime
        # cookie_dict = p_res.cookies.get_dict()
        # expires = datetime.utcnow() + app.permanent_session_lifetime
        # for k in cookie_dict.keys():
        #     httponly = True
        #     if k in ['phpMyAdmin']: httponly = True
        #     res.set_cookie(k, cookie_dict[k],
        #                         expires=expires, httponly=httponly,
        #                         path='/')

        return res

    def get_pma_phpversion(self):
        """
            @name 获取phpmyadmin的php版本
            @author hwliang<2022-01-19>
            @return str
        """
        from panelPlugin import panelPlugin
        pma_status = panelPlugin().getPHPMyAdminStatus()
        if 'phpversion' in pma_status:
            return pma_status['phpversion']
        return None

    def get_pma_version(self):
        """
            @name 获取phpmyadmin的版本
            @author hwliang<2022-01-19>
            @return str
        """
        pma_vfile = public.get_setup_path() + '/phpmyadmin/version.pl'
        if not os.path.exists(pma_vfile): return ''
        pma_version = public.readFile(pma_vfile).strip()
        if not pma_version: return ''
        return pma_version

    def set_pma_phpversion(self):
        """
            @name 设置phpmyadmin兼容的php版本
            @author hwliang<2022-01-19>
            @return str
        """

        pma_version = self.get_pma_version()
        if not pma_version: return False

        old_phpversion = self.get_pma_phpversion()
        if not old_phpversion: return False
        if pma_version == '4.0':
            php_versions = ['52', '53', '54']
        elif pma_version == '4.4':
            php_versions = ['54', '55', '56']
        elif pma_version == '4.9':
            php_versions = ['55', '56', '70', '71', '72', '73', '74']
        elif pma_version == '5.0':
            php_versions = ['70', '71', '72', '73', '74']
        elif pma_version == '5.1':
            php_versions = ['71', '72', '73', '74', '80']
        elif pma_version == '5.2':
            php_versions = ['72', '73', '74', '80', '81']
        elif pma_version == '5.3':
            php_versions = ['72', '73', '74', '80', '81']
        else:
            return False

        if old_phpversion in php_versions: return True

        installed_php_versions = []
        php_install_path = '/www/server/php'
        for version in php_versions:
            php_bin = php_install_path + '/' + version + '/bin/php'
            if os.path.exists(php_bin):
                installed_php_versions.append(version)

        if not installed_php_versions: return False

        php_version = installed_php_versions[-1]

        import ajax
        args = public.dict_obj()
        args.phpversion = php_version
        ajax.ajax().setPHPMyAdmin(args)
        public.WriteLog(
            'Database',
            'The PHP version used by phpMyAdmin has been detected to be incompatible and has been automatically changed to the best compatible version: PHP-' + php_version
        )
        time.sleep(0.5)

    def get_request_headers(self):
        """
            @name 获取请求头
            @author hwliang<2022-01-19>
            @return dict
        """
        headers = {}
        rm_cookies = [app.config['SESSION_COOKIE_NAME'], 'bt_user_info', 'file_recycle_status', 'ltd_end',
                      'memSize', 'page_number', 'pro_end', 'request_token', 'serverType', 'site_model',
                      'sites_path', 'soft_remarks', 'load_page', 'Path', 'distribution', 'order']
        for k in request.headers.keys():
            headers[k] = request.headers.get(k)
            if k == 'Cookie':
                # noinspection PyUnresolvedReferences
                cookie_dict = SimpleCookie(headers[k])
                for rm_cookie in rm_cookies:
                    if rm_cookie in cookie_dict:
                        del (cookie_dict[rm_cookie])
                headers[k] = cookie_dict.output(header='', sep=';').strip()
        return headers

    def form_to_dict(self, form):
        """
            @name 将表单转为字典
            @author hwliang<2022-02-18>
            @param form<request.form> 表单数据
            @return dict
        """

        data = {}
        for k in form.keys():
            data[k] = form.getlist(k)
            if len(data[k]) == 1: data[k] = data[k][0]
        return data

    def proxy(self, proxy_url: str, allow_redirects: bool = False):
        """
            @name 代理指定URL地址
            @author hwliang<2022-01-19>
            @param proxy_url<string> 被代理的URL地址
            @return Response
        """
        try:
            urllib3_conn.allowed_gai_family = lambda: socket.AF_INET
            s_key = 'proxy_{}_{}'.format(app.secret_key, self.get_pma_version())

            if not s_key in session:
                session[s_key] = requests.Session()
                session[s_key].keep_alive = False
                session[s_key].headers = {
                    'User-Agent': 'Yak-Panel',
                    'Connection': 'close'
                }

                if proxy_url.find('phpmyadmin') != -1:
                    if proxy_url.find('https://') == 0:
                        session[s_key].cookies.update({'pma_lang_https': 'zh_CN'})
                    else:
                        session[s_key].cookies.update({'pma_lang': 'zh_CN'})
                    self.set_pma_phpversion()

            if 'Authorization' in request.headers:
                session[s_key].headers['Authorization'] = request.headers['Authorization']

            try:
                session[s_key].headers['Host'] = public.en_punycode(
                    request.url_root
                ).replace('http://', '').replace('https://', '').split('/')[0]
            except:
                pass
            headers = None
            if request.method == 'GET':
                # 转发GET请求
                p_res = session[s_key].get(
                    proxy_url, headers=headers, verify=False, allow_redirects=allow_redirects
                )
            elif request.method == 'POST':
                # 转发POST请求
                if request.files:  # 如果上传文件
                    tmp_path = '{}/tmp'.format(public.get_panel_path())
                    if not os.path.exists(tmp_path): os.makedirs(tmp_path, 384)

                    # 遍历form表单中的所有文件
                    files = {}
                    f_list = {}
                    for key in request.files:
                        upload_files = request.files.getlist(key)
                        filename = upload_files[0].filename
                        if not filename: filename = public.GetRandomString(12)
                        tmp_file = '{}/{}'.format(tmp_path, filename)

                        # 保存上传文件到临时目录
                        with open(tmp_file, 'wb') as f:
                            for tmp_f in upload_files:
                                f.write(tmp_f.read())
                            f.close()

                        # 构造文件上传对象
                        f_list[key] = open(tmp_file, 'rb')
                        files[key] = (filename, f_list[key])

                        # 删除临时文件
                        if os.path.exists(tmp_file): os.remove(tmp_file)

                    # 转发上传请求

                    p_res = session[s_key].post(
                        proxy_url,
                        self.form_to_dict(request.form),
                        headers=headers,
                        files=files,
                        verify=False,
                        allow_redirects=allow_redirects
                    )

                    # 释放文件对象
                    for fkey in f_list.keys():
                        f_list[fkey].close()
                else:
                    p_res = session[s_key].post(
                        proxy_url,
                        self.form_to_dict(request.form),
                        headers=headers,
                        verify=False,
                        allow_redirects=allow_redirects
                    )
            else:
                return Response('不支持的请求类型', 500)

            # PHP版本自动切换处理
            if proxy_url.find('phpmyadmin') != -1 and proxy_url.find('/index.php') != -1:
                if len(p_res.content) < 1024:
                    if p_res.content.find(b'syntax error, unexpected') != -1 or p_res.content.find(
                            b'offset access syntax with') != -1 or p_res.content.find(b'+ is required') != -1:
                        self.set_pma_phpversion()
                        return 'Incompatible PHP version, an attempt has been made to automatically switch to a compatible PHP version, please refresh the page and try again!'
                elif p_res.content.find(b'<strong>Deprecation Notice</strong>') != -1 and not session.get(
                        'set_pma_phpversion'):
                    self.set_pma_phpversion()
                    session['set_pma_phpversion'] = True
                    return 'Incompatible PHP version, an attempt has been made to automatically switch to a compatible PHP version, please refresh the page and try again!'

            res = Response(
                p_res.content,
                headers=self.get_res_headers(p_res),
                content_type=p_res.headers.get('content-type', None),
                status=p_res.status_code
            )
            res = self.set_res_headers(res, p_res)
            return res
        except Exception as ex:
            err_msg = re.sub(r"adminer_\S+", "adminer_...", str(ex))
            err_msg = re.sub(r"phpmyadmin_\S+", "phpmyadmin_...", err_msg)
            return Response(err_msg, 500)

    # todo未完善
    def proxy_socket(self, proxy_url: str, allow_redirects: bool = False):
        """
        @name socket代理
        @param proxy_url http+unix://<socket_path>/<request_uri>
        @return Response
        """
        try:
            if not proxy_url.startswith("http+unix://"):
                return self._err_resp(
                    "Socket proxy error: proxy_url format error. It should start with 'http+unix://'"
                )

            from urllib.parse import urlparse, urlunparse, quote
            try:
                from requests_unixsocket import Session as ux_Session
            except ImportError:
                public.ExecShell("btpip install requests_unixsocket")
                try:
                    # noinspection PyUnresolvedReferences
                    from requests_unixsocket import Session as ux_Session
                except:
                    return self._err_resp("The 'requests_unixsocket' module is not installed")
            parsed_url = urlparse(proxy_url)
            if parsed_url.scheme == "http+unix":
                full_path = parsed_url.netloc + parsed_url.path
                if not full_path.startswith("/"):
                    full_path = "/" + full_path

                socket_ext = ".sock"
                socket_pos = full_path.find(socket_ext)
                if socket_pos != -1:
                    socket_path_end = socket_pos + len(socket_ext)
                    socket_path = full_path[:socket_path_end]
                    request_uri = full_path[socket_path_end:]
                    if not request_uri:
                        request_uri = "/"

                    encoded_socket_path = quote(socket_path, safe="")
                    # format: http+unix://<socket_path>/<request_uri>
                    proxy_url = urlunparse((
                        parsed_url.scheme,
                        encoded_socket_path,
                        request_uri,
                        parsed_url.params,
                        parsed_url.query,
                        parsed_url.fragment
                    ))
                else:
                    return self._err_resp("Socket proxy error: Invalid socket proxy URL format.")

            sess = ux_Session()
            headers = self.get_request_headers()
            if request.method == "GET":
                p_res = sess.get(
                    proxy_url, headers=headers, timeout=10, allow_redirects=allow_redirects
                )
            elif request.method == "POST":
                data = self.form_to_dict(request.form)
                files = None
                if request.files:
                    files = {}
                    for key in request.files:
                        fs = request.files.getlist(key)[0]
                        files[key] = (fs.filename, fs.stream)

                p_res = sess.post(
                    proxy_url, data=data, files=files, headers=headers, timeout=10, allow_redirects=allow_redirects
                )
            else:
                return self._err_resp(f"Unsupported method: {request.method}")

            return Response(
                p_res.content,
                status=p_res.status_code,
                headers=headers,
                content_type=p_res.headers.get("content-type", None)
            )

        except Exception as ex:
            return self._err_resp(f"Socket proxy error: {str(ex)}")