import mysql.connector
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import joblib
from sklearn.preprocessing import OneHotEncoder
import sqlite3

# MySQL 연결
db = mysql.connector.connect(
    host="localhost",
    user="global",
    password="vdP)QRBKOY]5QNdw",
    database="global"
)
cursor = db.cursor()

# # 테이블 생성
# cursor.execute('''
# CREATE TABLE IF NOT EXISTS used_pc_price (
#     id INT AUTO_INCREMENT PRIMARY KEY,
#     cpu VARCHAR(255),
#     gpu VARCHAR(255),
#     ram INT,
#     ssd INT,
#     hdd INT,
#     price INT
# )
# ''')

# # 샘플 데이터 생성 함수
# def generate_sample_data():
#     cpus = ['Intel i3', 'Intel i5', 'Intel i7', 'AMD Ryzen 3', 'AMD Ryzen 5', 'AMD Ryzen 7']
#     gpus = ['NVIDIA GTX 1650', 'NVIDIA RTX 2060', 'NVIDIA RTX 3070', 'AMD RX 570', 'AMD RX 5700', 'AMD RX 6800']

#     for _ in range(50):
#         cpu = np.random.choice(cpus)
#         gpu = np.random.choice(gpus)
#         ram = np.random.choice([4, 8, 16, 32, 64])
#         ssd = np.random.choice([128, 256, 512, 1024])
#         hdd = np.random.choice([0, 500, 1000, 2000])

#         # 대여가격(30일기준) 생성 (간단한 규칙 기반)
#         price = 300000 + (cpus.index(cpu) + 1) * 50000 + (gpus.index(gpu) + 1) * 100000 + ram * 10000 + ssd * 200 + hdd * 100

#         cursor.execute('INSERT INTO used_pc_price (cpu, gpu, ram, ssd, hdd, price) VALUES (%s, %s, %s, %s, %s, %s)',
#                        (cpu, gpu, ram, ssd, hdd, price))

# # 데이터가 없으면 샘플 데이터 생성
# cursor.execute('SELECT COUNT(*) FROM used_pc_price')
# if cursor.fetchone()[0] == 0:
#     generate_sample_data()
#     db.commit()

# 데이터 불러오기
df = pd.read_sql_query("SELECT * FROM used_pc_price", db)

# CPU와 GPU 모델 정규화 함수
def normalize_cpu_gpu(model):
    if 'Intel' in model:
        return 'Intel'
    elif 'AMD' in model:
        return 'AMD'
    elif 'NVIDIA' in model or 'GeForce' in model:
        return 'NVIDIA'
    else:
        return 'Other'

# CPU와 GPU 정규화 적용
df['cpu'] = df['cpu'].apply(normalize_cpu_gpu)
df['gpu'] = df['gpu'].apply(normalize_cpu_gpu)

# 특성 엔코딩
df = pd.get_dummies(df, columns=['cpu', 'gpu'])

# 특성과 타겟 분리
X = df.drop(['id', 'price'], axis=1)
y = df['price']

# 학습 및 테스트 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 학습
model = LinearRegression()
model.fit(X_train, y_train)

# 모델 평가
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f"평균 제곱 오차: {mse}")

# g5_shop_item 테이블에서 데이터 가져오기
cursor.execute('''
    SELECT it_id, it_spec_cpu, it_spec_gpu, it_spec_ram, it_spec_ssd, it_spec_hdd
    FROM g5_shop_item
''')
items = cursor.fetchall()

# 숫자만 추출하는 함수
def extract_number(value):
    return int(''.join(filter(str.isdigit, value or '0')))

# 각 아이템에 대해 예측 수행
for item in items:
    it_id, cpu, gpu, ram, ssd, hdd = item

    # 데이터 정규화 및 전처리
    cpu = normalize_cpu_gpu(cpu)
    gpu = normalize_cpu_gpu(gpu)
    ram = extract_number(ram)
    ssd = extract_number(ssd)
    hdd = extract_number(hdd)

    # 데이터프레임 생성
    item_df = pd.DataFrame({
        'cpu': [cpu],
        'gpu': [gpu],
        'ram': [ram],
        'ssd': [ssd],
        'hdd': [hdd]
    })

    # 원-핫 인코딩 적용
    item_df = pd.get_dummies(item_df, columns=['cpu', 'gpu'])

    # 학습 데이터와 동일한 열을 가지도록 조정
    for col in X.columns:
        if col not in item_df.columns:
            item_df[col] = 0

    item_df = item_df[X.columns]

    # 대여가격(30일기준) 예측
    predicted_price = model.predict(item_df)[0]

    # 1일 대여가격으로 환산
    daily_price = predicted_price / 30

    # g5_shop_item 테이블 업데이트
    cursor.execute('''
        UPDATE g5_shop_item
        SET ai_suggested_price = %s
        WHERE it_id = %s
    ''', (daily_price, it_id))

# 변경사항 저장
db.commit()

print("모든 아이템의 AI 제안 가격이 업데이트되었습니다.")

# 연결 종료
cursor.close()
db.close()