# 所需庫(kù)（Python內(nèi)置，無(wú)需額外安裝）
import tkinter
import threading
import smtplib
import socket

 python ip_monitor.py

# 同時(shí)驗(yàn)證IP可達(dá)性和端口開(kāi)放狀態(tài)
if ping_success and port_open:
    return ONLINE

def check_target(self, ip, port=None, timeout=2):
    """智能檢測(cè)IP/端口狀態(tài)"""
    try:
        if port:  # 端口檢測(cè)模式
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.settimeout(timeout)
                s.connect((ip, port))
                return IPStatus.ONLINE
        else:     # 純Ping模式
            # 使用ICMP協(xié)議實(shí)現(xiàn)Ping
            sock = socket.socket(socket.AF_INET, 
                               socket.SOCK_RAW, 
                               socket.IPPROTO_ICMP)
            sock.settimeout(timeout)
            sock.connect((ip, 1))
            return IPStatus.ONLINE
    except socket.timeout:
        return IPStatus.OFFLINE
    except Exception:
        return IPStatus.UNKNOWN

class MonitorThread(threading.Thread):
    def __init__(self, app):
        super().__init__(daemon=True)
        self.app = app
        self.running = True
        
    def run(self):
        while self.running:
            # 1. 執(zhí)行所有目標(biāo)的檢測(cè)
            # 2. 觸發(fā)狀態(tài)變更通知
            # 3. 智能休眠控制CPU占用
            time.sleep(self.calculate_sleep_time())
            
    def stop(self):
        self.running = False

def save_config(self):
    """JSON格式保存所有配置"""
    config = {
        'targets': [
            self.tree.item(item, 'values')
            for item in self.tree.get_children()
        ],
        'email_settings': {
            'smtp': self.smtp_entry.get(),
            'user': self.user_entry.get(),
            'pass': self.pass_entry.get(),
            'receivers': self.receiver_entry.get()
        }
    }
    with open('config.json', 'w') as f:
        json.dump(config, f, indent=2)

# 示例：企業(yè)微信機(jī)器人API
import requests
def send_wechat_alert(message):
    webhook = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx"
    requests.post(webhook, json={"text": {"content": message}})

# 使用SQLite記錄狀態(tài)變化
import sqlite3
conn = sqlite3.connect('monitor.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS status_log
             (ip TEXT, port INT, status TEXT, check_time TIMESTAMP)''')

# 使用Matplotlib繪制可用率曲線
plt.plot(dates, availability_rates)
plt.title('月度服務(wù)可用率')
plt.ylabel('百分比(%)')
plt.savefig('report.png')

import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext
import threading
import time
import smtplib
import ipaddress
import re
import json
import socket
from email.message import EmailMessage
from enum import Enum


class IPStatus(Enum):
    ONLINE = 1
    OFFLINE = 2
    UNKNOWN = 3


class IPMonitorApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("IP狀態(tài)監(jiān)測(cè)系統(tǒng)")
        self.geometry("1300x850")
        
        try:
            self.iconbitmap('monitor.ico')
        except:
            pass

        self.style = ttk.Style()
        self.configure_style()
        
        self.stop_event = threading.Event()
        self.monitor_thread = None
        self.ip_status = {}
        self.next_report_time = self.calculate_next_report_time()
        
        self.create_widgets()
        self.load_config()

    def configure_style(self):
        self.style.theme_create('ipmonitor', parent='alt', settings={
            'TFrame': {'configure': {'background': '#f5f5f5'}},
            'TLabelFrame': {
                'configure': {
                    'background': '#f5f5f5',
                    'foreground': '#1e3d59',
                    'font': ('微軟雅黑', 10, 'bold')
                }
            },
            'TLabel': {
                'configure': {
                    'background': '#f5f5f5',
                    'foreground': '#1e3d59',
                    'font': ('微軟雅黑', 10)
                }
            },
            'TButton': {
                'configure': {
                    'background': '#1e3d59',
                    'foreground': 'white',
                    'font': ('微軟雅黑', 10),
                    'padding': 5
                },
                'map': {
                    'background': [('active', '#3a6ea5')],
                    'foreground': [('disabled', '#888888')]
                }
            },
            'TCheckbutton': {
                'configure': {
                    'background': '#f5f5f5',
                    'font': ('微軟雅黑', 10)
                }
            }
        })
        self.style.theme_use('ipmonitor')

    def create_widgets(self):
        # 主容器
        main_frame = ttk.Frame(self, padding=10)
        main_frame.grid(row=0, column=0, sticky="nsew")
        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(0, weight=1)
        
        # 配置區(qū)域
        config_frame = ttk.Frame(main_frame)
        config_frame.grid(row=0, column=0, sticky="nsew")
        
        # IP配置區(qū)域
        ip_frame = ttk.LabelFrame(config_frame, text="監(jiān)測(cè)目標(biāo)配置", padding=10)
        ip_frame.grid(row=0, column=0, padx=5, pady=5, sticky="nsew")
        ip_frame.columnconfigure(0, weight=1)
        
        # IP列表Treeview
        self.ip_tree = ttk.Treeview(
            ip_frame, 
            columns=("check", "ip", "port", "remark"), 
            show="headings",
            height=8,
            selectmode="browse"
        )
        self.ip_tree.grid(row=0, column=0, sticky="nsew")
        
        # 配置列
        self.ip_tree.heading("check", text="檢測(cè)")
        self.ip_tree.heading("ip", text="IP地址")
        self.ip_tree.heading("port", text="端口")
        self.ip_tree.heading("remark", text="備注")
        
        self.ip_tree.column("check", width=50, anchor="center")
        self.ip_tree.column("ip", width=150, anchor="w")
        self.ip_tree.column("port", width=80, anchor="center")
        self.ip_tree.column("remark", width=250, anchor="w")
        
        # 添加復(fù)選框
        self.ip_tree.tag_configure("checked", background="#e6f7ff")
        self.ip_tree.tag_configure("unchecked", background="#f5f5f5")
        
        # 編輯區(qū)域
        edit_frame = ttk.Frame(ip_frame)
        edit_frame.grid(row=1, column=0, sticky="ew", pady=(5, 0))
        
        ttk.Label(edit_frame, text="IP:").grid(row=0, column=0, sticky="e")
        self.ip_entry = ttk.Entry(edit_frame, width=18)
        self.ip_entry.grid(row=0, column=1, padx=2, sticky="w")
        
        ttk.Label(edit_frame, text="端口:").grid(row=0, column=2, sticky="e")
        self.port_entry = ttk.Entry(edit_frame, width=8)
        self.port_entry.grid(row=0, column=3, padx=2, sticky="w")
        
        ttk.Label(edit_frame, text="備注:").grid(row=0, column=4, sticky="e")
        self.remark_entry = ttk.Entry(edit_frame, width=20)
        self.remark_entry.grid(row=0, column=5, padx=2, sticky="w")
        
        # 操作按鈕
        btn_frame = ttk.Frame(edit_frame)
        btn_frame.grid(row=0, column=6, padx=5)
        
        ttk.Button(btn_frame, text="添加", command=self.add_ip).grid(row=0, column=0, padx=2)
        ttk.Button(btn_frame, text="更新", command=self.update_ip).grid(row=0, column=1, padx=2)
        ttk.Button(btn_frame, text="刪除", command=self.remove_ip).grid(row=0, column=2, padx=2)
        
        # 郵件配置區(qū)域
        mail_frame = ttk.LabelFrame(config_frame, text="郵件通知配置", padding=10)
        mail_frame.grid(row=0, column=1, padx=5, pady=5, sticky="nsew")
        
        # 郵件配置項(xiàng)
        mail_config = [
            ("SMTP服務(wù)器:端口", "smtp_server", "smtp.163.com:465"),
            ("郵箱賬戶", "email_user", "yourname@163.com"),
            ("郵箱授權(quán)碼", "email_pass", ""),
            ("接收郵箱", "email_receiver", "多個(gè)郵箱用逗號(hào)分隔")
        ]
        
        for i, (label, attr, ph) in enumerate(mail_config):
            ttk.Label(mail_frame, text=label).grid(row=i, column=0, sticky="e", pady=3)
            entry = ttk.Entry(mail_frame, width=25)
            entry.grid(row=i, column=1, padx=5, pady=3, sticky="ew")
            setattr(self, attr+"_entry", entry)
            ttk.Label(mail_frame, text=ph, foreground="#888888").grid(row=i, column=2, sticky="w", padx=5)
        
        # 監(jiān)控參數(shù)
        param_frame = ttk.LabelFrame(config_frame, text="監(jiān)控參數(shù)", padding=10)
        param_frame.grid(row=1, column=0, columnspan=2, sticky="ew", pady=(5, 0))
        
        params = [
            ("監(jiān)測(cè)間隔(秒):", "interval", "10"),
            ("超時(shí)(秒):", "timeout", "2"),
            ("重試次數(shù):", "retry", "3"),
            ("重試間隔(秒):", "retry_interval", "5")
        ]
        
        for i, (label, attr, default) in enumerate(params):
            ttk.Label(param_frame, text=label).grid(row=0, column=i*2, sticky="e")
            entry = ttk.Entry(param_frame, width=8)
            entry.insert(0, default)
            entry.grid(row=0, column=i*2+1, padx=5, sticky="w")
            setattr(self, attr+"_entry", entry)
        
        # 控制按鈕
        ctrl_frame = ttk.Frame(config_frame)
        ctrl_frame.grid(row=2, column=0, columnspan=2, pady=(10, 0), sticky="e")
        
        ttk.Button(ctrl_frame, text="開(kāi)始監(jiān)測(cè)", command=self.start_monitoring).grid(row=0, column=0, padx=5)
        ttk.Button(ctrl_frame, text="停止監(jiān)測(cè)", command=self.stop_monitoring, state=tk.DISABLED).grid(row=0, column=1, padx=5)
        self.start_btn = ctrl_frame.grid_slaves(row=0, column=0)[0]
        self.stop_btn = ctrl_frame.grid_slaves(row=0, column=1)[0]
        
        ttk.Button(ctrl_frame, text="保存配置", command=self.save_config).grid(row=0, column=2, padx=5)
        ttk.Button(ctrl_frame, text="清空日志", command=self.clear_logs).grid(row=0, column=3, padx=5)
        
        # 狀態(tài)監(jiān)控區(qū)域
        status_frame = ttk.LabelFrame(main_frame, text="狀態(tài)監(jiān)控", padding=10)
        status_frame.grid(row=1, column=0, sticky="nsew", pady=(5, 0))
        
        self.status_tree = ttk.Treeview(
            status_frame, 
            columns=("ip", "port", "remark", "status", "last_check"), 
            show="headings",
            height=8
        )
        self.status_tree.grid(row=0, column=0, sticky="nsew")
        
        # 狀態(tài)列配置
        for col, width in [("ip", 150), ("port", 80), ("remark", 200), ("status", 100), ("last_check", 180)]:
            self.status_tree.column(col, width=width, anchor="center")
            self.status_tree.heading(col, text=col)
        
        # 日志區(qū)域
        log_frame = ttk.LabelFrame(main_frame, text="系統(tǒng)日志", padding=10)
        log_frame.grid(row=2, column=0, sticky="nsew", pady=(5, 0))
        
        self.log_text = scrolledtext.ScrolledText(
            log_frame, 
            wrap=tk.WORD, 
            font=('微軟雅黑', 9), 
            bg='white', 
            fg='#333333',
            height=10
        )
        self.log_text.pack(fill=tk.BOTH, expand=True)
        
        # 配置權(quán)重
        main_frame.columnconfigure(0, weight=1)
        main_frame.rowconfigure(1, weight=1)
        main_frame.rowconfigure(2, weight=1)
        
        config_frame.columnconfigure(1, weight=1)
        
        ip_frame.rowconfigure(0, weight=1)
        ip_frame.columnconfigure(0, weight=1)
        
        status_frame.rowconfigure(0, weight=1)
        status_frame.columnconfigure(0, weight=1)
        
        # 綁定事件
        self.ip_tree.bind("<Button-1>", self.on_tree_click)
        self.ip_tree.bind("<Double-1>", self.on_tree_double_click)

    def on_tree_click(self, event):
        """處理樹(shù)狀圖點(diǎn)擊事件"""
        region = self.ip_tree.identify("region", event.x, event.y)
        if region == "cell":
            column = self.ip_tree.identify_column(event.x)
            item = self.ip_tree.identify_row(event.y)
            if column == "#1":  # 復(fù)選框列
                current_val = self.ip_tree.item(item, "values")[0]
                new_val = "?" if current_val == "" else ""
                values = list(self.ip_tree.item(item, "values"))
                values[0] = new_val
                self.ip_tree.item(item, values=values, tags=("checked" if new_val else "unchecked"))

    def on_tree_double_click(self, event):
        """處理樹(shù)狀圖雙擊事件"""
        item = self.ip_tree.selection()
        if item:
            values = self.ip_tree.item(item, "values")
            self.ip_entry.delete(0, tk.END)
            self.ip_entry.insert(0, values[1])
            self.port_entry.delete(0, tk.END)
            self.port_entry.insert(0, values[2])
            self.remark_entry.delete(0, tk.END)
            self.remark_entry.insert(0, values[3])

    def add_ip(self):
        """添加IP到列表"""
        ip = self.ip_entry.get().strip()
        port = self.port_entry.get().strip()
        remark = self.remark_entry.get().strip()
        
        if not ip:
            messagebox.showwarning("錯(cuò)誤", "IP地址不能為空")
            return
            
        if not self.is_valid_ip(ip):
            messagebox.showwarning("錯(cuò)誤", "無(wú)效的IP地址格式")
            return
            
        if port:
            try:
                port = int(port)
                if not (1 <= port <= 65535):
                    messagebox.showwarning("錯(cuò)誤", "端口必須在1-65535之間")
                    return
            except ValueError:
                messagebox.showwarning("錯(cuò)誤", "端口必須是數(shù)字")
                return
        
        self.ip_tree.insert("", tk.END, values=("?", ip, port, remark), tags=("checked",))
        
        # 清空輸入框
        self.ip_entry.delete(0, tk.END)
        self.port_entry.delete(0, tk.END)
        self.remark_entry.delete(0, tk.END)

    def update_ip(self):
        """更新選中的IP"""
        item = self.ip_tree.selection()
        if not item:
            messagebox.showwarning("錯(cuò)誤", "請(qǐng)先選擇要更新的項(xiàng)")
            return
            
        ip = self.ip_entry.get().strip()
        port = self.port_entry.get().strip()
        remark = self.remark_entry.get().strip()
        
        if not ip:
            messagebox.showwarning("錯(cuò)誤", "IP地址不能為空")
            return
            
        if not self.is_valid_ip(ip):
            messagebox.showwarning("錯(cuò)誤", "無(wú)效的IP地址格式")
            return
            
        if port:
            try:
                port = int(port)
                if not (1 <= port <= 65535):
                    messagebox.showwarning("錯(cuò)誤", "端口必須在1-65535之間")
                    return
            except ValueError:
                messagebox.showwarning("錯(cuò)誤", "端口必須是數(shù)字")
                return
        
        # 保留原來(lái)的復(fù)選框狀態(tài)
        current_check = self.ip_tree.item(item, "values")[0]
        self.ip_tree.item(item, values=(current_check, ip, port, remark))

    def remove_ip(self):
        """刪除選中的IP"""
        items = self.ip_tree.selection()
        if not items:
            messagebox.showwarning("錯(cuò)誤", "請(qǐng)先選擇要?jiǎng)h除的項(xiàng)")
            return
            
        for item in items:
            self.ip_tree.delete(item)

    def is_valid_ip(self, ip):
        """驗(yàn)證IP地址格式"""
        try:
            ipaddress.ip_address(ip)
            return True
        except ValueError:
            return False

    def start_monitoring(self):
        """開(kāi)始監(jiān)控"""
        if not self.validate_inputs():
            return
            
        # 獲取要監(jiān)控的目標(biāo)
        targets = []
        for item in self.ip_tree.get_children():
            check, ip, port, remark = self.ip_tree.item(item, "values")
            if check == "?":  # 只監(jiān)控選中的項(xiàng)
                targets.append((ip, int(port) if port else None, remark))
        
        if not targets:
            messagebox.showwarning("錯(cuò)誤", "沒(méi)有選中要監(jiān)控的目標(biāo)")
            return
            
        # 初始化狀態(tài)字典
        self.ip_status = {}
        for ip, port, remark in targets:
            self.ip_status[(ip, port)] = {
                "status": IPStatus.UNKNOWN,
                "last_notified": None,
                "remark": remark,
                "retries": 0,
                "next_retry_time": 0,
                "last_check": "從未檢測(cè)"
            }
        
        # 更新?tīng)顟B(tài)顯示
        self.update_status_display()
        
        # 更新按鈕狀態(tài)
        self.start_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)
        self.stop_event.clear()
        
        # 獲取監(jiān)控參數(shù)
        interval = int(self.interval_entry.get())
        timeout = int(self.timeout_entry.get())
        max_retries = int(self.retry_entry.get())
        retry_interval = int(self.retry_interval_entry.get())
        
        # 創(chuàng)建監(jiān)控線程
        self.monitor_thread = threading.Thread(
            target=self.monitor_targets,
            args=(interval, timeout, max_retries, retry_interval),
            daemon=True
        )
        self.monitor_thread.start()
        
        self.log_message("監(jiān)控已啟動(dòng)")

    def stop_monitoring(self):
        """停止監(jiān)控"""
        self.stop_event.set()
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        self.log_message("監(jiān)控已停止")

    def monitor_targets(self, interval, timeout, max_retries, retry_interval):
        """監(jiān)控主循環(huán)"""
        while not self.stop_event.is_set():
            current_time = time.time()

            # 每日?qǐng)?bào)告檢查
            if current_time >= self.next_report_time:
                self.send_daily_report()
                self.next_report_time = self.calculate_next_report_time()

            # 檢查所有目標(biāo)
            for (ip, port), data in list(self.ip_status.items()):
                if self.stop_event.is_set():
                    break

                if current_time < data['next_retry_time']:
                    continue

                # 執(zhí)行檢測(cè)
                if port:  # 如果有端口則檢測(cè)端口
                    current_status = self.check_port(ip, port, timeout)
                else:  # 否則只ping IP
                    current_status = self.ping_ip(ip, timeout)
                
                previous_status = data["status"]
                data["last_check"] = time.strftime("%Y-%m-%d %H:%M:%S")
                
                # 處理狀態(tài)變化
                if current_status == IPStatus.OFFLINE:
                    if data['retries'] < max_retries:
                        data['retries'] += 1
                        data['next_retry_time'] = current_time + retry_interval
                        self.log_message(f"{ip}:{port or '無(wú)端口'} 檢測(cè)失敗，正在進(jìn)行第 {data['retries']} 次重試...")
                    else:
                        if previous_status != current_status:
                            self.send_alert(ip, port, data['remark'], current_status)
                        data["status"] = current_status
                        data['retries'] = 0
                        data['next_retry_time'] = current_time + interval
                else:
                    if previous_status != current_status:
                        self.send_alert(ip, port, data['remark'], current_status)
                    data["status"] = current_status
                    data['retries'] = 0
                    data['next_retry_time'] = current_time + interval
                
                # 更新UI
                self.after(0, self.update_status_display)

            # 計(jì)算睡眠時(shí)間
            next_checks = [data['next_retry_time'] for data in self.ip_status.values()]
            next_check = min(next_checks) if next_checks else current_time + interval
            sleep_time = max(min(next_check - time.time(), interval), 0.1)
            time.sleep(sleep_time)

    def ping_ip(self, ip, timeout):
        """Ping IP地址"""
        try:
            # 使用socket創(chuàng)建ICMP ping
            sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
            sock.settimeout(timeout)
            sock.connect((ip, 1))  # 端口號(hào)不重要
            return IPStatus.ONLINE
        except socket.timeout:
            return IPStatus.OFFLINE
        except Exception:
            return IPStatus.UNKNOWN
        finally:
            try:
                sock.close()
            except:
                pass

    def check_port(self, ip, port, timeout):
        """檢查端口"""
        try:
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.settimeout(timeout)
                s.connect((ip, port))
                return IPStatus.ONLINE
        except socket.timeout:
            return IPStatus.OFFLINE
        except ConnectionRefusedError:
            return IPStatus.OFFLINE
        except Exception as e:
            self.log_message(f"檢測(cè)異常: {str(e)}")
            return IPStatus.UNKNOWN

    def update_status_display(self):
        """更新?tīng)顟B(tài)顯示"""
        # 清空現(xiàn)有顯示
        for item in self.status_tree.get_children():
            self.status_tree.delete(item)
        
        # 添加新?tīng)顟B(tài)
        for (ip, port), data in self.ip_status.items():
            status = data["status"]
            status_text = "在線" if status == IPStatus.ONLINE else "離線" if status == IPStatus.OFFLINE else "未知"
            status_color = "green" if status == IPStatus.ONLINE else "red" if status == IPStatus.OFFLINE else "orange"
            
            item = self.status_tree.insert("", tk.END, values=(
                ip, 
                port if port else "無(wú)", 
                data["remark"], 
                status_text, 
                data["last_check"]
            ))
            self.status_tree.tag_configure(status_color, foreground=status_color)
            self.status_tree.item(item, tags=(status_color,))

    def send_alert(self, ip, port, remark, status):
        """發(fā)送狀態(tài)變更通知"""
        status_text = "在線" if status == IPStatus.ONLINE else "離線"
        subject = f"IP狀態(tài)變更: {remark or ip}:{port if port else '無(wú)端口'} - {status_text}"
        
        content = "\n".join([
            f"IP地址: {ip}",
            f"端口: {port if port else '無(wú)'}",
            f"備注: {remark or '無(wú)備注信息'}",
            f"狀態(tài)變更為: {status_text}",
            f"檢測(cè)時(shí)間: {time.strftime('%Y-%m-%d %H:%M:%S')}"
        ])
        
        try:
            self.send_email(subject, content)
            self.log_message(f"已發(fā)送狀態(tài)變更通知: {ip}:{port if port else '無(wú)'} -> {status_text}")
        except Exception as e:
            self.log_message(f"郵件發(fā)送失敗: {str(e)}")

    def send_email(self, subject, content):
        """發(fā)送郵件"""
        smtp_server = self.smtp_server_entry.get().strip()
        user = self.email_user_entry.get().strip()
        password = self.email_pass_entry.get().strip()
        receiver_str = self.email_receiver_entry.get().strip()
        
        if not all([smtp_server, user, password, receiver_str]):
            raise Exception("郵件配置不完整")
        
        receivers = [addr.strip() for addr in receiver_str.split(',') if addr.strip()]
        
        msg = EmailMessage()
        msg['Subject'] = subject
        msg['From'] = user
        msg['To'] = receivers
        msg.set_content(content)
        
        server, port = smtp_server.split(":")
        port = int(port)
        
        try:
            if port == 465:
                with smtplib.SMTP_SSL(server, port) as smtp:
                    smtp.login(user, password)
                    smtp.send_message(msg)
            else:
                with smtplib.SMTP(server, port) as smtp:
                    smtp.starttls()
                    smtp.login(user, password)
                    smtp.send_message(msg)
        except Exception as e:
            raise Exception(f"SMTP錯(cuò)誤: {str(e)}")

    def send_daily_report(self):
        """發(fā)送每日?qǐng)?bào)告"""
        report_lines = []
        for (ip, port), data in self.ip_status.items():
            status = data["status"]
            status_text = "在線" if status == IPStatus.ONLINE else "離線" if status == IPStatus.OFFLINE else "未知"
            report_lines.append(f"IP: {ip}:{port if port else '無(wú)'} 備注: {data['remark']} 狀態(tài): {status_text}")
        
        current_time = time.strftime("%Y-%m-%d %H:%M:%S")
        content = "每日IP狀態(tài)報(bào)告\n\n" + "\n".join(report_lines) + f"\n\n報(bào)告時(shí)間: {current_time}"
        subject = "每日IP狀態(tài)報(bào)告"
        
        try:
            self.send_email(subject, content)
            self.log_message("已發(fā)送每日狀態(tài)報(bào)告")
        except Exception as e:
            self.log_message(f"發(fā)送每日?qǐng)?bào)告失敗: {str(e)}")

    def calculate_next_report_time(self):
        """計(jì)算下次報(bào)告時(shí)間"""
        now = time.localtime()
        today_10am = time.mktime((now.tm_year, now.tm_mon, now.tm_mday, 10, 0, 0, 0, 0, -1))
        current_time = time.time()
        
        return today_10am + 86400 if current_time >= today_10am else today_10am

    def log_message(self, message):
        """記錄日志"""
        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
        log_line = f"[{timestamp}] {message}\n"
        
        self.log_text.insert(tk.END, log_line)
        self.log_text.see(tk.END)
        
        with open("monitor.log", "a", encoding="utf-8") as f:
            f.write(log_line)

    def clear_logs(self):
        """清空日志"""
        self.log_text.delete(1.0, tk.END)

    def validate_inputs(self):
        """驗(yàn)證輸入"""
        # 檢查郵件配置
        smtp_server = self.smtp_server_entry.get().strip()
        user = self.email_user_entry.get().strip()
        password = self.email_pass_entry.get().strip()
        receiver_str = self.email_receiver_entry.get().strip()
        
        if not smtp_server:
            messagebox.showwarning("錯(cuò)誤", "SMTP服務(wù)器不能為空")
            return False
            
        if ":" not in smtp_server:
            messagebox.showwarning("錯(cuò)誤", "SMTP服務(wù)器格式應(yīng)為 host:port")
            return False
            
        if not user:
            messagebox.showwarning("錯(cuò)誤", "郵箱賬戶不能為空")
            return False
            
        if not password:
            messagebox.showwarning("錯(cuò)誤", "郵箱授權(quán)碼不能為空")
            return False
            
        if not receiver_str:
            messagebox.showwarning("錯(cuò)誤", "接收郵箱不能為空")
            return False
            
        # 驗(yàn)證監(jiān)控參數(shù)
        try:
            interval = int(self.interval_entry.get())
            timeout = int(self.timeout_entry.get())
            retries = int(self.retry_entry.get())
            retry_interval = int(self.retry_interval_entry.get())
            
            if interval < 5:
                messagebox.showwarning("錯(cuò)誤", "監(jiān)測(cè)間隔不能小于5秒")
                return False
                
            if timeout < 1:
                messagebox.showwarning("錯(cuò)誤", "超時(shí)時(shí)間不能小于1秒")
                return False
                
            if retries < 0:
                messagebox.showwarning("錯(cuò)誤", "重試次數(shù)不能為負(fù)數(shù)")
                return False
                
            if retry_interval < 1:
                messagebox.showwarning("錯(cuò)誤", "重試間隔不能小于1秒")
                return False
                
        except ValueError:
            messagebox.showwarning("錯(cuò)誤", "請(qǐng)輸入有效的數(shù)字")
            return False
            
        return True

    def save_config(self):
        """保存配置"""
        config = {
            "targets": [
                self.ip_tree.item(item, "values")
                for item in self.ip_tree.get_children()
            ],
            "smtp_server": self.smtp_server_entry.get(),
            "email_user": self.email_user_entry.get(),
            "email_pass": self.email_pass_entry.get(),
            "email_receiver": self.email_receiver_entry.get(),
            "interval": self.interval_entry.get(),
            "timeout": self.timeout_entry.get(),
            "retry": self.retry_entry.get(),
            "retry_interval": self.retry_interval_entry.get()
        }
        
        try:
            with open("config.json", "w", encoding="utf-8") as f:
                json.dump(config, f, indent=2)
            self.log_message("配置已保存")
            messagebox.showinfo("成功", "配置已保存到config.json")
        except Exception as e:
            self.log_message(f"保存配置失敗: {str(e)}")
            messagebox.showerror("錯(cuò)誤", f"保存配置失敗: {str(e)}")

    def load_config(self):
        """加載配置"""
        try:
            with open("config.json", encoding="utf-8") as f:
                config = json.load(f)
            
            # 加載目標(biāo)
            for item in self.ip_tree.get_children():
                self.ip_tree.delete(item)
                
            for values in config.get("targets", []):
                self.ip_tree.insert("", tk.END, values=values, tags=("checked" if values[0] == "?" else "unchecked"))
            
            # 加載郵件配置
            self.smtp_server_entry.delete(0, tk.END)
            self.smtp_server_entry.insert(0, config.get("smtp_server", ""))
            
            self.email_user_entry.delete(0, tk.END)
            self.email_user_entry.insert(0, config.get("email_user", ""))
            
            self.email_pass_entry.delete(0, tk.END)
            self.email_pass_entry.insert(0, config.get("email_pass", ""))
            
            self.email_receiver_entry.delete(0, tk.END)
            self.email_receiver_entry.insert(0, config.get("email_receiver", ""))
            
            # 加載監(jiān)控參數(shù)
            self.interval_entry.delete(0, tk.END)
            self.interval_entry.insert(0, config.get("interval", "10"))
            
            self.timeout_entry.delete(0, tk.END)
            self.timeout_entry.insert(0, config.get("timeout", "2"))
            
            self.retry_entry.delete(0, tk.END)
            self.retry_entry.insert(0, config.get("retry", "3"))
            
            self.retry_interval_entry.delete(0, tk.END)
            self.retry_interval_entry.insert(0, config.get("retry_interval", "5"))
            
            self.log_message("配置已加載")
        except FileNotFoundError:
            self.log_message("未找到配置文件，使用默認(rèn)配置")
        except Exception as e:
            self.log_message(f"加載配置失敗: {str(e)}")


if __name__ == "__main__":
    app = IPMonitorApp()
    app.mainloop()