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
import re
import importlib
import logging
import mysql.connector
import pandas as pd
from db_config import get_db_connection
import time
from datetime import datetime
import resource
import requests

# 로깅 설정
logging.basicConfig(filename='/dev/null', level=logging.WARNING,
                    format='%(asctime)s - %(levelname)s - %(message)s')

def ensure_connection(db):
    try:
        logging.info("데이터베이스 연결 확인 중...")
        db.ping(reconnect=True, attempts=3, delay=5)
        logging.info("데이터베이스 연결 성공")
    except mysql.connector.Error as err:
        logging.error(f"연결 오류: {err}")
        try:
            logging.info("데이터베이스 재연결 시도 중...")
            db.reconnect(attempts=3, delay=5)
            logging.info("데이터베이스 재연결 성공")
        except mysql.connector.Error as err:
            logging.error(f"재연결 실패: {err}")
            raise

# price_org 컬럼의 'NA' 값 처리 함수
def process_na_price(df):
    logging.info("NA 가격 처리 시작")
    # 'NA' 값을 가진 행을 찾습니다
    na_mask = df['price'] == 'NA'

    for idx in df[na_mask].index:
        rank = df.loc[idx, 'rank']

        # 상위 순위 데이터 찾기
        upper_price = df[(df['rank'] < rank) & (df['price'].notna())]['price'].last_valid_index()

        # 하위 순위 데이터 찾기
        lower_price = df[(df['rank'] > rank) & (df['price'].notna())]['price'].first_valid_index()

        if upper_price is not None and lower_price is not None:
            # 상위와 하위 순위 사이의 평균 가격 계산
            df.loc[idx, 'price'] = (float(df.loc[upper_price, 'price']) + float(df.loc[lower_price, 'price'])) / 2
        elif upper_price is not None:
            # 상위 순위 가격의 95% 적용
            df.loc[idx, 'price'] = float(df.loc[upper_price, 'price']) * 0.95
        elif lower_price is not None:
            # 하위 순위 가격의 105% 적용
            df.loc[idx, 'price'] = float(df.loc[lower_price, 'price']) * 1.05
        else:
            # 모든 데이터가 'NA'인 경우 (예외 처리)
            df.loc[idx, 'price'] = df['price'].mean()

    logging.info("NA 가격 처리 완료")
    return df


# price_org 컬럼 데이터 정제 함수
# def clean_price(price):
#     logging.info("NA 가격 처리 시작")
#     if isinstance(price, str):
#         price = re.sub(r'[^\d.]', '', price)
#         parts = price.split('.')
#         if len(parts) > 1:
#             price = parts[0] + '.' + parts[1][:2]
#         else:
#             price = parts[0]
#     try:
#         logging.info("NA 가격 처리 완료")
#         return float(price)
#     except ValueError as e:
#         logging.exception(f"예상치 못한 오류 발생: {e}")
#         return None

def clean_price(price):
    if isinstance(price, str):
        # 숫자와 소수점만 남기고 나머지 제거
        price = re.sub(r'[^\d.]', '', price)
        # 소수점이 두 개 이상 있으면 첫 번째 소수점만 남김
        parts = price.split('.')
        if len(parts) > 2:
            price = parts[0] + '.' + ''.join(parts[1:])
    try:
        return float(price)
    except ValueError:
        return None

def print_memory_usage():
    usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
    print(f"현재 메모리 사용량: {usage / 1024:.2f} MB")

# 환율 정보를 가져오는 함수
def get_exchange_rate():
    try:
        response = requests.get("https://api.exchangerate-api.com/v4/latest/USD")
        data = response.json()
        return data['rates']['KRW']
    except:
        print("환율 정보를 가져오는데 실패했습니다. 기본 환율 1300원을 사용합니다.")
        return 1300

# USD를 KRW로 변환하는 함수
def usd_to_krw(usd_price, exchange_rate):
    return int(usd_price * exchange_rate)

def main():
    start_time = time.time()  # 프로그램 시작 시간 기록
    start_datetime = datetime.now()  # 프로그램 시작 날짜와 시간 기록
    print(f"프로그램 시작: {start_datetime.strftime('%Y-%m-%d %H:%M:%S.%f')}")  # 시작 시간 출력
    try:
        logging.info("프로그램 시작")

        # # df_cpu_inc.py 파일을 동적으로 import
        # logging.info("df_cpu_inc 모듈 import 시도")
        # df_cpu_inc = importlib.import_module('df_cpu_inc')
        # logging.info("df_cpu_inc 모듈 import 성공")

        # # df_cpu_inc 모듈의 함수들을 현재 네임스페이스로 가져오기
        # globals().update(df_cpu_inc.__dict__)


        # # df_gpu_inc.py 파일을 동적으로 import
        # logging.info("df_gpu_inc 모듈 import 시도")
        # df_gpu_inc = importlib.import_module('df_gpu_inc')
        # logging.info("df_gpu_inc 모듈 import 성공")

        # # df_gpu_inc 모듈의 함수들을 현재 네임스페이스로 가져오기
        # globals().update(df_gpu_inc.__dict__)


        # # df_hdd_inc.py 파일을 동적으로 import
        # logging.info("df_hdd_inc 모듈 import 시도")
        # df_hdd_inc = importlib.import_module('df_hdd_inc')
        # logging.info("df_hdd_inc 모듈 import 성공")

        # # df_hdd_inc 모듈의 함수들을 현재 네임스페이스로 가져오기
        # globals().update(df_hdd_inc.__dict__)


        # # df_ram_inc.py 파일을 동적으로 import
        # logging.info("df_ram_inc 모듈 import 시도")
        # df_ram_inc = importlib.import_module('df_ram_inc')
        # logging.info("df_ram_inc 모듈 import 성공")

        # # df_ram_inc 모듈의 함수들을 현재 네임스페이스로 가져오기
        # globals().update(df_ram_inc.__dict__)


        # AI 모델 학습 파일 생성
        # # df_ai_model_study_inc.py 파일을 동적으로 import
        # logging.info("df_ai_model_study_inc 모듈 import 시도")
        # df_ai_model_study_inc = importlib.import_module('df_ai_model_study_inc')
        # logging.info("df_ai_model_study_inc 모듈 import 성공")

        # # df_ai_model_study_inc 모듈의 함수들을 현재 네임스페이스로 가져오기
        # globals().update(df_ai_model_study_inc.__dict__)



        # MySQL 연결
        # logging.info("데이터베이스 연결 시도")
        # db = get_db_connection()
        # logging.info("데이터베이스 연결 성공")

        logging.info("프로그램 정상 종료")
    except Exception as e:
        logging.exception(f"예상치 못한 오류 발생: {e}")
        raise
    finally:
        end_time = time.time()  # 프로그램 종료 시간 기록
        end_datetime = datetime.now()  # 프로그램 종료 날짜와 시간 기록
        print(f"프로그램 종료: {end_datetime.strftime('%Y-%m-%d %H:%M:%S.%f')}")  # 종료 시간 출력
        execution_time = end_time - start_time  # 실행 시간 계산
        print(f"프로그램 총 실행 시간: {execution_time:.2f}초")  # 실행 시간 출력

if __name__ == "__main__":
    main()