import requests
import json
import os
import sys
from pathlib import Path
import urllib3

# 禁用SSL警告（与JS中的 rejectUnauthorized: false 等效）
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)


class CreosonClient:
    def __init__(self):
        self.creoson_url = 'http://localhost:9056/creoson'
        self.timeout = 60 
        self.session_id = ''

    def creoson_post(self, command: str, function_name: str, data: dict = None) -> dict:
        if data is None:
            data = {}

        request_body = {
            "command": command,
            "function": function_name
        }

        if self.session_id:
            request_body["sessionId"] = self.session_id

        if data:
            request_body["data"] = data

        post_data = json.dumps(request_body, ensure_ascii=False)

        print(f"[调试] 请求URL: {self.creoson_url}")
        print(f"[调试] {command}.{function_name} {post_data}")

        try:
            response = requests.post(
                self.creoson_url,
                data=post_data.encode('utf-8'),
                timeout=self.timeout,
                headers={
                    'Content-Type': 'application/json; charset=UTF-8',
                    'Content-Length': str(len(post_data.encode('utf-8')))
                },
                verify=False
            )

            response.raise_for_status()
            result = response.json()

            if not isinstance(result, dict):
                raise Exception(f"[JSON解析错误] 响应: {response.text} | 错误: 无效的JSON格式")

            status = result.get('status', {})
            if status.get('error') is True:
                msg = status.get('message', '未知错误')
                if msg == 'No session found':
                    error = Exception(f"[会话未就绪] {msg}")
                    error.code = 1001
                    raise error
                raise Exception(f"[Creoson错误] {msg}")

            if command == 'connection' and function_name == 'connect' and result.get('sessionId'):
                self.session_id = result['sessionId']
                print(f"[会话] 获取到官方SessionID: {self.session_id}")

            return result

        except requests.exceptions.Timeout:
            raise Exception(f"[请求超时] 请求超时（{self.timeout}秒）")
        except requests.exceptions.HTTPError as e:
            raise Exception(f"[HTTP错误] 状态码: {e.response.status_code} | 响应: {e.response.text}")
        except requests.exceptions.ConnectionError as e:
            raise Exception(f"[CURL错误] 无法连接到服务器: {str(e)}")
        except json.JSONDecodeError:
            raise Exception(f"[JSON解析错误] 响应: {response.text} | 错误: 无效的JSON格式")
        except Exception:
            raise

    def start_creo(self, config: dict):
        print("【1/6】发送Creo启动命令...")
        self.creoson_post('connection', 'start_creo', config)
        print("【1/6】Creo启动命令发送完成！")

    def connect(self):
        print("【2/6】建立Creoson会话...")
        self.creoson_post('connection', 'connect')
        print("【2/6】检测Creo会话就绪状态...")

    def creo_cd(self, dir_name: str):
        print(f"【3/6】切换Creo工作目录到: {dir_name}")
        abs_dir = Path(dir_name).resolve()

        if not abs_dir.exists() or not abs_dir.is_dir():
            raise Exception(f"目录不存在或无效: {dir_name}（绝对路径: {abs_dir}）")

        self.creoson_post('creo', 'cd', {
            "dirname": str(abs_dir)
        })
        print("【3/6】工作目录切换成功！")

    def file_open(self, file: str, generic: str = "", display: bool = True, activate: bool = True):
        print(f"【4/6】打开Creo文件: {file}")
        file_name = Path(file).name
        abs_file = Path("D:\\mydoc\\Creoson_test\\") / file_name

        if not abs_file.exists() or not abs_file.is_file():
            raise Exception(f"文件不存在或无效: {file}（完整路径: {abs_file}）")

        params = {
            "file": file_name,
            "display": display,
            "activate": activate
        }

        if generic:
            params["generic"] = generic

        self.creoson_post('file', 'open', params)
        print("【4/6】文件打开成功！")

    def parameter_set(self, name: str, value: str, type_: str = 'STRING'):
        print(f"【5/6】设置参数 {name} = {value}（类型: {type_}）")
        self.creoson_post('parameter', 'set', {
            "name": name,
            "type": type_,
            "value": value,
            "no_create": False,
            "designate": True
        })
        print("【5/6】参数设置成功！")

    def file_save(self, file: str):
        print(f"【6/6】保存Creo文件: {file}")
        file_name = Path(file).name
        abs_file = Path("D:\\mydoc\\Creoson_test\\") / file_name

        if not abs_file.exists():
            raise Exception(f"文件路径无效: {file}（完整路径: {abs_file}）")

        self.creoson_post('file', 'save', {
            "file": file_name
        })
        print("【6/6】文件保存成功！")


def main():
    try:
        client = CreosonClient()
        creo_config = {
            "start_dir": 'D:\\mydoc\\Creoson_test',
            "start_command": 'nitro_proe_remote.bat',
            "retries": 5,
            "use_desktop": False
        }

        client.start_creo(creo_config)
        client.connect()
        client.creo_cd('D:\\mydoc\\Creoson_test')
        client.file_open("fin.prt", "fin")
        client.parameter_set("test", "PYthon调用CREOSON添加的参数", "STRING")
        client.file_save("fin.prt")

        print("\n===== 全流程执行完成！=====")
    except Exception as error:
        print("\n===== 执行失败 =====")
        print(f"错误详情: {error}")
        if hasattr(error, 'code'):
            print(f"错误代码: {error.code}")
        sys.exit(1)


if __name__ == "__main__":
    main()

import creopyson
import os

current_dir = os.getcwd()
# 初始化
c = creopyson.Client()

# 启动Creo
# nitro_proe_remote.bat复制自parametric.bat，不知道CREOSON为什么默认改成这个名字
# 修改nitro_proe_remote.bat用于自定义配置
command = "connection"
function = "start_creo"
data = {"start_dir": current_dir, "start_command": "nitro_proe_remote.bat", "retries": 5}
result = c._creoson_post(command, function, data)
# 这样也行
# c.start_creo(current_dir + "\\nitro_proe_remote.bat", 5, False)

c.connect()  # 这个必须得要，否则后面会提示没有sessionID

# 修改工作目录为程序所在目录
command = "creo"
function = "cd"
data = {"dirname": current_dir}
result = c._creoson_post(command, function, data)
# 这样也行
# c.creo_cd(current_dir)

# 打开文件并显示
command = "file"
function = "open"
data = {"file": "fin.prt", "display": True, "activate": True}
result = c._creoson_post(command, function, data)
# 这样也行
# c.file_open("fin.prt", display=True)

# 添加或修改参数
command = "parameter"
function = "set"
data = {"name": "test", "type": "STRING", "value": "测试参数值", "no_create": False, "designate": True}
result = c._creoson_post(command, function, data)
# 这样也行
# c.parameter_set("test", "测试参数值2", None, "STRING", None, True, False)

# 保存文件
command = "file"
function = "save"
data = {"file": "FIN.PRT"}
result = c._creoson_post(command, function, data)
# 这样也行
# c.file_save("fin.prt")

# -*- coding: utf-8 -*-
import json
import os
import pvporcupine
import pyaudio
import struct
import wave
import time
import subprocess
import tempfile
import threading
import queue
import signal
from aip import AipSpeech
import appbuilder

# ---------- 1. 读取配置 ----------
with open(os.path.join(os.path.dirname(__file__), "config.json"), "r", encoding="utf-8") as f:
    CFG = json.load(f)

# ---------- 2. 初始化 Porcupine ----------
porc = pvporcupine.create(**CFG["porcupine"])

# ---------- 3. 初始化百度语音 ----------
baidu_cfg = CFG["baidu_asr_tts"]
client = AipSpeech(baidu_cfg["APP_ID"], baidu_cfg["API_KEY"], baidu_cfg["SECRET_KEY"])

# ---------- 4. 初始化千帆 ----------
os.environ["APPBUILDER_TOKEN"] = CFG["qianfan"]["APPBUILDER_TOKEN"]
_qianfan_client = appbuilder.AppBuilderClient(CFG["qianfan"]["APP_ID"])
_qianfan_conversation_id = _qianfan_client.create_conversation()

def ask_qianfan(query: str) -> str:
    try:
        print("千帆请求中...")
        ans = _qianfan_client.run(_qianfan_conversation_id, query).content.answer
        print("千帆返回：", ans)
        return ans
    except Exception as e:
        print("千帆请求失败：", e)
        return "网络开小差了，稍后再试"

# ---------- 5. 常量 & 音频流 ----------
SAMPLE_RATE = 16000
FRAME_LEN = 512
SILENCE_SEC = 1.0
SILENCE_RMS = 150
WAV_FILE = "temp.wav"

pa = pyaudio.PyAudio()
kw_stream = pa.open(format=pyaudio.paInt16, channels=1,
                    rate=SAMPLE_RATE, input=True,
                    frames_per_buffer=FRAME_LEN)

def play_prompt(audio_file):
    if os.path.exists(audio_file):
        os.system(f"aplay -q {audio_file}")
    else:
        print(f"警告：音频文件 {audio_file} 不存在，跳过播放")

# ---------- 6. 后台播放线程：预加载 + 连续播放 ----------
stop_play = threading.Event()      # 主线程→播放线程：立即停
text_queue = queue.Queue()         # 主线程把「待播放文本」塞进来
preload_queue = queue.Queue(maxsize=1)  # 预合成 wav 路径（最大 1 段）
_play_thread = None

def _play_worker():
    while True:
        text = text_queue.get()
        if text is None:           # 退出信号
            break

        stop_play.clear()
        # ---- 6.1 问千帆（可被打断） ----
        if stop_play.is_set():
            continue
        answer = ask_qianfan(text)
        if stop_play.is_set():
            continue

        # ---- 6.2 长文本分段（<=512 字节 GBK） ----
        seg_list, cur, cur_len = [], '', 0
        for ch in answer:
            ch_len = len(ch.encode('gbk', errors='ignore'))
            if cur_len + ch_len > 512 and cur:
                seg_list.append(cur)
                cur, cur_len = ch, ch_len
            else:
                cur += ch
                cur_len += ch_len
        if cur:
            seg_list.append(cur)
        if not seg_list:
            continue
        if stop_play.is_set():
            continue

        # ---- 6.3 预合成 + 连续播放 ----
        tmp_base = tempfile.mktemp()
        n = len(seg_list)

        # 先合成第一段
        def _preload_one(idx):
            if idx >= n or stop_play.is_set():
                return None
            seg = seg_list[idx]
            try:
                print(f"TTS 合成段落 {idx}: {seg}")
                wav_bytes = client.synthesis(seg, 'zh', 1,
                                             {'spd': 5, 'pit': 5, 'vol': 9, 'per': 0})
                if not isinstance(wav_bytes, bytes):
                    return None
            except Exception as e:
                print('TTS 异常：', e)
                return None
            raw = tmp_base + f'_{idx}_raw.wav'
            with open(raw, 'wb') as f:
                f.write(wav_bytes)
            target = tmp_base + f'_{idx}_16k.wav'
            subprocess.run(['ffmpeg', '-y', '-i', raw,
                            '-ar', '16000', '-ac', '1', '-sample_fmt', 's16',
                            '-b:a', '256k', target],
                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            os.unlink(raw)
            return target

        # 预合成第一段
        next_wav = _preload_one(0)
        if not next_wav:
            continue

        # 顺序播放 & 后台预合成下一段
        for i in range(n):
            if stop_play.is_set():
                try: os.unlink(next_wav)
                except: pass
                break
            # 播放当前段
            print("播放段落", i)
            player = subprocess.Popen(['aplay', '-q', next_wav])
            # 后台开始合成下一段
            if i + 1 < n:
                t = threading.Thread(target=lambda idx: preload_queue.put(_preload_one(idx)),
                                     args=(i + 1,), daemon=True)
                t.start()
            # 等待当前段播完
            while player.poll() is None:
                if stop_play.is_set():
                    player.send_signal(signal.SIGTERM)
                    player.wait(timeout=0.5)
                    break
                time.sleep(0.05)
            try: os.unlink(next_wav)
            except: pass
            if stop_play.is_set():
                break
            # 取出下一段 wav
            if i + 1 < n:
                try:
                    next_wav = preload_queue.get(timeout=10)
                except queue.Empty:
                    next_wav = None
                if not next_wav:
                    break

# 启动播放线程
_play_thread = threading.Thread(target=_play_worker, daemon=True)
_play_thread.start()

# ---------- 7. 录音 ----------
def record_audio(filename=WAV_FILE, silence_sec=SILENCE_SEC, threshold=SILENCE_RMS):
    print("开始录音...")
    max_silent = int(silence_sec * SAMPLE_RATE / FRAME_LEN)
    rec_stream = pa.open(format=pyaudio.paInt16, channels=1,
                         rate=SAMPLE_RATE, input=True,
                         frames_per_buffer=FRAME_LEN * 4)
    frames, silent_frames = [], 0
    for _ in range(max_silent * 10):
        try:
            data = rec_stream.read(FRAME_LEN, exception_on_overflow=False)
        except OSError:
            continue
        frames.append(data)
        pcm = struct.unpack("h" * FRAME_LEN, data)
        rms = (sum(x * x for x in pcm) / FRAME_LEN) ** 0.5
        print(f"\rRMS={rms:.0f} ", end="", flush=True)
        if rms < threshold:
            silent_frames += 1
        else:
            silent_frames = 0
        if silent_frames > max_silent:
            break
    rec_stream.stop_stream(); rec_stream.close()
    print("\n录音结束")
    with wave.open(filename, 'wb') as wf:
        wf.setnchannels(1)
        wf.setsampwidth(pa.get_sample_size(pyaudio.paInt16))
        wf.setframerate(SAMPLE_RATE)
        wf.writeframes(b''.join(frames))
    return filename

# ---------- 8. 语音识别 ----------
def asr(filename):
    with open(filename, 'rb') as f:
        res = client.asr(f.read(), 'wav', 16000, {'dev_pid': 1537})
    return res['result'][0] if res.get('err_no') == 0 else None

# ---------- 9. 主循环：永远检测唤醒词 ----------
try:
    print("等待唤醒词“小派”...")
    while True:
        pcm = kw_stream.read(FRAME_LEN, exception_on_overflow=False)
        pcm = struct.unpack("h" * FRAME_LEN, pcm)
        if porc.process(pcm) >= 0:
            print("\n【唤醒】检测到“小派”！")
            stop_play.set()                 # 1. 立即打断正在进行的播放
            play_prompt(CFG["audio"]["prompt_wav"])

            wav = record_audio()
            play_prompt(CFG["audio"]["confirm_wav"])
            text = asr(wav)
            if text:
                print("识别结果：", text)
                text_queue.put(text)       # 2. 把文本交给后台线程
            else:
                text_queue.put("我没听清，请再说一遍")
            print("等待下次唤醒...")
except KeyboardInterrupt:
    print("\n程序退出")
finally:
    stop_play.set()
    text_queue.put(None)        # 通知播放线程退出
    _play_thread.join(timeout=2)
    kw_stream.close()
    pa.terminate()
    porc.delete()