from flask import Flask, request, jsonify
from flask_cors import CORS
import psycopg2
import psycopg2.extras
import os
from datetime import datetime
import json
import requests
from urllib.parse import urlparse, parse_qs
import re

import logging
logging.basicConfig(level=logging.DEBUG)

import os
import base64
import uuid
from werkzeug.utils import secure_filename

app = Flask(__name__)
CORS(app)

# Конфигурация базы данных
DB_CONFIG = {
    'host': '127.0.0.1',
    'database': 'aliexpress_automation',
    'user': 'postgres',
    'password': 'PostgresPass123'
}


def get_db_connection():
    """Получение соединения с базой данных"""
    try:
        print(f"🔌 Попытка подключения к БД с параметрами: {DB_CONFIG}")
        conn = psycopg2.connect(**DB_CONFIG)
        print("✅ Соединение с БД установлено успешно")
        return conn
    except Exception as e:
        print(f"❌ Ошибка подключения к БД: {e}")
        raise

def validate_url(url):
    """Валидация URL"""
    try:
        result = urlparse(url)
        return all([result.scheme, result.netloc])
    except:
        return False

def extract_product_id_from_url(url):
    """Извлечение ID товара из URL AliExpress"""
    try:
        # Поиск product_id в URL
        match = re.search(r'(\d+)\.html', url)
        if match:
            return match.group(1)
        
        # Альтернативный способ поиска ID
        match = re.search(r'item/(\d+)', url)
        if match:
            return match.group(1)
        
        return None
    except:
        return None
        
        
        
UPLOAD_FOLDER = '/var/www/html/mycamper/aliexpress-site/frontend/images/products'
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'webp'}

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

def save_base64_image(base64_data, product_id=None):
    """Сохранение base64 изображения в файл"""
    try:
        # Извлекаем данные после data:image/...;base64,
        if 'data:image/' in base64_data:
            header, data = base64_data.split(',', 1)
            # Определяем расширение из header
            if 'png' in header:
                ext = 'png'
            elif 'jpeg' in header or 'jpg' in header:
                ext = 'jpg'
            elif 'gif' in header:
                ext = 'gif'
            elif 'webp' in header:
                ext = 'webp'
            else:
                ext = 'png'  # По умолчанию
        else:
            data = base64_data
            ext = 'png'
        
        # Генерируем уникальное имя файла
        unique_id = str(uuid.uuid4())
        if product_id:
            filename = f"product_{product_id}_{unique_id}.{ext}"
        else:
            filename = f"image_{unique_id}.{ext}"
        
        # Полный путь к файлу
        filepath = os.path.join(UPLOAD_FOLDER, filename)
        
        # Создаем папку, если её нет
        os.makedirs(UPLOAD_FOLDER, exist_ok=True)
        
        # Декодируем и сохраняем
        image_data = base64.b64decode(data)
        with open(filepath, 'wb') as f:
            f.write(image_data)
        
        # Возвращаем URL для доступа к файлу
        file_url = f"/frontend/images/products/{filename}"
        return file_url, None
        
    except Exception as e:
        return None, str(e)

@app.route('/api/upload-image', methods=['POST'])
def upload_image():
    """Endpoint для загрузки изображений"""
    try:
        data = request.get_json()
        
        if not data or 'image' not in data:
            return jsonify({
                'success': False,
                'error': 'Изображение не предоставлено'
            }), 400
        
        base64_image = data['image']
        product_id = data.get('product_id')
        
        # Сохраняем изображение
        file_url, error = save_base64_image(base64_image, product_id)
        
        if error:
            return jsonify({
                'success': False,
                'error': f'Ошибка сохранения изображения: {error}'
            }), 500
        
        return jsonify({
            'success': True,
            'image_url': file_url,
            'message': 'Изображение успешно загружено'
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

# Добавить маршрут для статических файлов
@app.route('/static/images/products/<filename>')
def uploaded_file(filename):
    """Отдача загруженных изображений"""
    try:
        from flask import send_from_directory
        return send_from_directory(UPLOAD_FOLDER, filename)
    except:
        return "File not found", 404
        
        

def categorize_product(title, description):
    """Автоматическое определение категории товара"""
    text = (title + ' ' + description).lower()
    
    # Категории для кемпера
    categories = {
        'electronics': ['panel słoneczny', 'bateria', 'falownik', 'ładowarka', 'latarka', 'radio', 'gps', 'nawigator', 'bateria', 'power bank', 'dioda LED', 'oświetlenie'],
        'cooking': ['kuchenka', 'garnek', 'patelnia', 'lodówka', 'termos', 'naczynia', 'gaz', 'palnik', 'rondel', 'wielofunkcyjny garnek'],
        'comfort': ['śpiwór', 'poduszka', 'materac', 'koc', 'krzesło', 'stół', 'leżanka', 'hamak', 'namiot', 'markiza'],
        'tools': ['narzędzie', 'śrubokręt', 'klucz', 'pompa', 'sprężarka', 'podnośnik', 'kabel', 'lina', 'wyciągarka'],
        'safety': ['apteczka', 'gaśnica', 'alarm', 'zamek', 'sejf', 'czujnik', 'kamera', 'zabezpieczenia'],
        'water': ['filtr', 'pompa', 'zbiornik', 'kran', 'wąż', 'prysznic', 'toaleta', 'szambo', 'czyszczenie']
    }
    
    for category, keywords in categories.items():
        if any(keyword in text for keyword in keywords):
            return category
    
    return 'other'

def get_product_images(product_id):
    """Получение всех изображений товара"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
        
        cursor.execute("""
            SELECT id, image_url, is_main, sort_order, alt_text, created_at
            FROM product_images
            WHERE product_id = %s
            ORDER BY sort_order ASC, id ASC
        """, (product_id,))
        
        images = []
        for row in cursor.fetchall():
            images.append({
                'id': row['id'],
                'image_url': row['image_url'],
                'is_main': row['is_main'],
                'sort_order': row['sort_order'],
                'alt_text': row['alt_text'],
                'created_at': row['created_at'].isoformat() if row['created_at'] else None
            })
        
        cursor.close()
        conn.close()
        
        return images
    except Exception as e:
        print(f"Error getting product images: {e}")
        return []
        
        
        
@app.route('/api/products', methods=['POST'])
def add_product():
    """Добавление нового товара"""
    conn = None
    cursor = None
    try:
        data = request.get_json()
        print(f"📥 Получены данные для добавления товара: {data}")
        
        # Валидация обязательных полей
        required_fields = ['title', 'price', 'aliexpress_link']
        for field in required_fields:
            if not data.get(field):
                return jsonify({
                    'success': False,
                    'error': f'Поле {field} обязательно для заполнения'
                }), 400
        
        # Валидация URL
        if not validate_url(data['aliexpress_link']):
            return jsonify({
                'success': False,
                'error': 'Неверный формат URL'
            }), 400
        
        # Валидация цены
        try:
            price = float(data['price'])
            if price < 0:
                return jsonify({
                    'success': False,
                    'error': 'Цена не может быть отрицательной'
                }), 400
        except ValueError:
            return jsonify({
                'success': False,
                'error': 'Неверный формат цены'
            }), 400
        
        # Извлечение ID товара из URL
        product_id = extract_product_id_from_url(data['aliexpress_link'])
        
        # Автоматическое определение категории
        category = data.get('category')
        if not category:
            category = categorize_product(
                data['title'],
                data.get('original_description', '')
            )
        
        # Подключение к базе данных
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # Начинаем транзакцию явно
        conn.autocommit = False
        print("🔄 Начинаем транзакцию")
        
        # Проверка на дубликаты по URL
        cursor.execute("""
            SELECT id FROM products 
            WHERE aliexpress_link = %s OR (external_product_id = %s AND external_product_id IS NOT NULL)
        """, (data['aliexpress_link'], product_id))
        
        existing = cursor.fetchone()
        if existing:
            print(f"❌ Товар с таким URL уже существует: {existing[0]}")
            return jsonify({
                'success': False,
                'error': 'Товар с таким URL уже существует'
            }), 409
        
        # Обработка specifications
        specifications = data.get('specifications')
        if specifications:
            if isinstance(specifications, dict):
                specifications = json.dumps(specifications)
            elif isinstance(specifications, str):
                try:
                    json.loads(specifications)
                except json.JSONDecodeError:
                    specifications = None
            else:
                specifications = None
        
        # Безопасные функции преобразования
        def safe_float(value, default=0.0):
            if value is None or value == '' or value == 'None':
                return default
            try:
                return float(value)
            except (ValueError, TypeError):
                return default
        
        def safe_int(value, default=0):
            if value is None or value == '' or value == 'None':
                return default
            try:
                return int(float(value))
            except (ValueError, TypeError):
                return default
        
        def safe_str(value, default=''):
            if value is None or value == '' or value == 'None':
                return default
            if isinstance(value, (dict, list)):
                return json.dumps(value)
            return str(value)
        
        print(f"📊 Подготовленные спецификации: {specifications}")
        
        # Упрощенная вставка только с основными полями
        print("🔄 Используем упрощенную вставку...")
        
        simple_insert_query = """
            INSERT INTO products (
                title, ai_description, original_description, price, original_price,
                main_image, category, epn_link, aliexpress_link, rating, orders_count,
                external_product_id, status, created_at, updated_at
            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            RETURNING id
        """
        
        simple_params = [
            safe_str(data.get('title'), ''),                    # title
            safe_str(data.get('ai_description')),               # ai_description
            safe_str(data.get('original_description')),         # original_description
            safe_float(data.get('price'), 0),                   # price
            safe_float(data.get('original_price')) if data.get('original_price') else None,  # original_price
            safe_str(data.get('main_image')),                   # main_image
            safe_str(category),                                 # category
            safe_str(data.get('epn_link')),                     # epn_link
            safe_str(data.get('aliexpress_link'), ''),          # aliexpress_link
            safe_float(data.get('rating'), 0),                  # rating
            safe_int(data.get('orders_count'), 0),              # orders_count
            safe_str(product_id),                               # external_product_id
            'active',                                           # status
            datetime.now(),                                     # created_at
            datetime.now()                                      # updated_at
        ]
        
        print("🔍 Проверка упрощенных параметров:")
        for i, value in enumerate(simple_params):
            print(f"  {i+1:2d}. {value} (тип: {type(value)})")
        
        print("🚀 Выполняем упрощенную вставку товара...")
        cursor.execute(simple_insert_query, simple_params)
        
        # Получаем ID нового товара
        new_product_id = cursor.fetchone()[0]
        print(f"✅ Товар вставлен с ID: {new_product_id}")
        
                # Обновляем дополнительные поля отдельно
        update_fields = []
        update_params = []
        
        # Безопасная обработка specifications
        safe_specifications = None
        if specifications:
            if isinstance(specifications, dict):
                safe_specifications = json.dumps(specifications)
            elif isinstance(specifications, str):
                safe_specifications = specifications
            else:
                safe_specifications = None
        
        additional_fields = {
            'detailed_description': safe_str(data.get('detailed_description')),
            'specifications': safe_specifications,  # ✅ Используем безопасную версию
            'shipping_info': safe_str(data.get('shipping_info')),
            'video_url': safe_str(data.get('video_url')),
            'weight': safe_float(data.get('weight')) if data.get('weight') else None,
            'dimensions': safe_str(data.get('dimensions')),
            'warranty_info': safe_str(data.get('warranty_info'))
        }
        
        print("🔍 Проверка дополнительных полей:")
        for field, value in additional_fields.items():
            print(f"  {field}: {value} (тип: {type(value)})")
            if isinstance(value, dict):
                print(f"    ❌ СЛОВАРЬ в {field}! Преобразуем...")
                value = json.dumps(value)
                additional_fields[field] = value
                print(f"    ✅ Преобразовано: {value}")
        
        for field, value in additional_fields.items():
            if value is not None and value != '':
                update_fields.append(f"{field} = %s")
                update_params.append(value)
        
        if update_fields:
            update_params.append(new_product_id)
            update_query = f"""
                UPDATE products 
                SET {', '.join(update_fields)}
                WHERE id = %s
            """
            print(f"🔄 Обновляем дополнительные поля: {update_fields}")
            print(f"🔢 Параметры обновления: {update_params}")
            cursor.execute(update_query, update_params)
            print("✅ Дополнительные поля обновлены")

        
    
        # Добавление изображений
        images = data.get('images', [])
        print(f"🖼️ Получены изображения для добавления: {len(images)} шт.")
        
        if images:
            print(f"🖼️ Начинаем обработку {len(images)} изображений")
            
            # Принудительно создаем таблицу, если её нет
            try:
                cursor.execute("""
                    CREATE TABLE IF NOT EXISTS product_images (
                        id SERIAL PRIMARY KEY,
                        product_id INTEGER NOT NULL,
                        image_url TEXT NOT NULL,
                        is_main BOOLEAN DEFAULT FALSE,
                        sort_order INTEGER DEFAULT 0,
                        alt_text VARCHAR(255),
                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                        
                        CONSTRAINT fk_product_images_product_id 
                            FOREIGN KEY (product_id) 
                            REFERENCES products(id) 
                            ON DELETE CASCADE
                    );
                """)
                print("✅ Таблица product_images готова")
            except Exception as create_error:
                print(f"❌ Ошибка создания таблицы: {create_error}")
            
            # Обрабатываем изображения
            for i, image in enumerate(images):
                try:
                    image_url = None
                    
                    print(f"🔍 Обработка изображения {i+1}")
                    
                    if isinstance(image, str):
                        image_data = image.strip()
                    elif isinstance(image, dict):
                        image_data = image.get('image_url', '').strip()
                    else:
                        print(f"⚠️ Неизвестный тип изображения {i+1}")
                        continue
                    
                    # Проверяем, это base64 данные или URL
                    if image_data.startswith('data:image/'):
                        print(f"📥 Изображение {i+1} в формате base64, сохраняем как файл...")
                        
                        # Сохраняем base64 как файл
                        file_url, error = save_base64_image(image_data, new_product_id)
                        
                        if error:
                            print(f"❌ Ошибка сохранения изображения {i+1}: {error}")
                            continue
                        
                        image_url = file_url
                        print(f"✅ Изображение {i+1} сохранено как файл: {image_url}")
                        
                    elif image_data.startswith(('http://', 'https://')):
                        print(f"🔗 Изображение {i+1} по URL: {image_data[:100]}...")
                        image_url = image_data
                        
                    else:
                        print(f"⚠️ Изображение {i+1} имеет неизвестный формат, пропускаем")
                        continue
                    
                    if image_url:
                        print(f"🚀 Добавляем изображение {i+1} в БД")
                        cursor.execute("""
                            INSERT INTO product_images (product_id, image_url, is_main, sort_order, alt_text)
                            VALUES (%s, %s, %s, %s, %s)
                            RETURNING id
                        """, (
                            new_product_id,
                            image_url,
                            i == 0,  # Первое изображение главное
                            i,
                            f'Image {i+1}'
                        ))
                        
                        image_id = cursor.fetchone()[0]
                        print(f"✅ Изображение {i+1} добавлено с ID {image_id}")
                        
                except Exception as img_error:
                    print(f"❌ Ошибка при обработке изображения {i+1}: {img_error}")
                    import traceback
                    traceback.print_exc()
                    continue
            
            # Проверяем результат
            cursor.execute("SELECT COUNT(*) FROM product_images WHERE product_id = %s", (new_product_id,))
            added_images_count = cursor.fetchone()[0]
            print(f"📊 Итого добавлено изображений: {added_images_count}")
        else:
            print("ℹ️ Изображения не предоставлены")


        
        # Принудительный коммит транзакции
        print("💾 Коммитим транзакцию...")
        conn.commit()
        
        # Финальная проверка
        cursor.execute("SELECT COUNT(*) FROM products WHERE id = %s", (new_product_id,))
        final_check = cursor.fetchone()[0]
        print(f"🔍 Финальная проверка: найдено {final_check} товаров с ID {new_product_id}")
        
        cursor.close()
        conn.close()
        
        print(f"✅ Товар ID {new_product_id} успешно добавлен и закоммичен в базу данных")
        
        return jsonify({
            'success': True,
            'message': 'Товар успешно добавлен',
            'product_id': new_product_id
        }), 201
        
    except Exception as e:
        print(f"❌ Ошибка при добавлении товара: {e}")
        import traceback
        traceback.print_exc()
        
        # Откат транзакции
        if conn:
            try:
                conn.rollback()
                print("🔄 Транзакция откачена")
            except:
                pass
        
        # Закрытие соединения
        if cursor:
            cursor.close()
        if conn:
            conn.close()
        
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500


@app.route('/api/products', methods=['GET'])
def get_products():
    """Получение списка товаров с фильтрацией и поиском"""
    try:
        print("🔍 Начало выполнения get_products()")
        
        page = int(request.args.get('page', 1))
        limit = int(request.args.get('limit', 12))
        category = request.args.get('category')
        price_range = request.args.get('price_range')
        search = request.args.get('search')
        status = request.args.get('status')
        
        if status is None:
            status = 'active'
        
        print(f"📋 Параметры: page={page}, limit={limit}, category={category}, status={status}")
        
        offset = (page - 1) * limit
        
        # Простой запрос товаров
        query = """
            SELECT id, title, ai_description, original_description, price, 
                   original_price, main_image, category, epn_link, 
                   aliexpress_link, rating, orders_count, status, created_at
            FROM products 
            WHERE status = %s
        """
        params = [status]
        
        if category:
            query += " AND category = %s"
            params.append(category)
            
        if price_range:
            if price_range == '0-100':
                query += " AND price <= %s"
                params.append(100)
            elif price_range == '100-500':
                query += " AND price > %s AND price <= %s"
                params.extend([100, 500])
            elif price_range == '500-1000':
                query += " AND price > %s AND price <= %s"
                params.extend([500, 1000])
            elif price_range == '1000+':
                query += " AND price > %s"
                params.append(1000)
        
        if search:
            query += " AND (title ILIKE %s OR ai_description ILIKE %s OR original_description ILIKE %s)"
            search_param = f"%{search}%"
            params.extend([search_param, search_param, search_param])
        
        query += " ORDER BY RANDOM() DESC LIMIT %s OFFSET %s"
        params.extend([limit, offset])
        
        print(f"📋 SQL запрос: {query}")
        print(f"🔢 Параметры: {params}")
        
        conn = get_db_connection()
        cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
        
        cursor.execute(query, params)
        rows = cursor.fetchall()
        
        print(f"📈 Получено товаров: {len(rows)}")
        
        products = []
        for i, row in enumerate(rows):
            try:
                print(f"🔄 Обработка товара {i+1}: {row['title']} (ID: {row['id']})")
                
                # Получаем изображения для каждого товара
                cursor.execute("""
                    SELECT id, image_url, is_main, sort_order, alt_text
                    FROM product_images
                    WHERE product_id = %s
                    ORDER BY sort_order ASC, id ASC
                """, (row['id'],))
                
                images_data = cursor.fetchall()
                images = [
                    {
                        'id': img['id'],
                        'image_url': img['image_url'],
                        'is_main': img['is_main'],
                        'sort_order': img['sort_order'],
                        'alt_text': img['alt_text']
                    }
                    for img in images_data
                ]
                
                print(f"🖼️ Товар {row['id']} имеет {len(images)} изображений")
                
                product = {
                    'id': row['id'],
                    'title': row['title'],
                    'ai_description': row['ai_description'],
                    'original_description': row['original_description'],
                    'price': float(row['price']) if row['price'] else 0,
                    'original_price': float(row['original_price']) if row['original_price'] else None,
                    'main_image': row['main_image'],
                    'category': row['category'],
                    'epn_link': row['epn_link'],
                    'aliexpress_link': row['aliexpress_link'],
                    'rating': float(row['rating']) if row['rating'] else 0,
                    'orders_count': row['orders_count'] or 0,
                    'status': row['status'],
                    'created_at': row['created_at'].isoformat() if row['created_at'] else None,
                    'images': images
                }
                
                products.append(product)
                
            except Exception as e:
                print(f"❌ Ошибка при обработке товара {i+1}: {e}")
                import traceback
                traceback.print_exc()
                continue
        
        cursor.close()
        conn.close()
        
        print(f"📤 Возвращаем результат: {len(products)} товаров")
        
        return jsonify({
            'success': True,
            'products': products,
            'page': page,
            'limit': limit
        })
        
    except Exception as e:
        print(f"❌ ОШИБКА в get_products(): {e}")
        import traceback
        traceback.print_exc()
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500


@app.route('/api/products/<int:product_id>', methods=['PUT'])
def update_product(product_id):
    """Обновление существующего товара"""
    conn = None
    cursor = None
    try:
        data = request.get_json()
        print(f"📥 Получены данные для обновления товара {product_id}: {data}")
        
        # Валидация обязательных полей
        required_fields = ['title', 'price', 'aliexpress_link']
        for field in required_fields:
            if not data.get(field):
                return jsonify({
                    'success': False,
                    'error': f'Поле {field} обязательно для заполнения'
                }), 400
        
        # Валидация URL
        if not validate_url(data['aliexpress_link']):
            return jsonify({
                'success': False,
                'error': 'Неверный формат URL'
            }), 400
        
        # Валидация цены
        try:
            price = float(data['price'])
            if price < 0:
                return jsonify({
                    'success': False,
                    'error': 'Цена не может быть отрицательной'
                }), 400
        except ValueError:
            return jsonify({
                'success': False,
                'error': 'Неверный формат цены'
            }), 400
        
        # Извлечение ID товара из URL
        external_product_id = extract_product_id_from_url(data['aliexpress_link'])
        
        # Проверка на существование товара
        conn = get_db_connection()
        cursor = conn.cursor()
        conn.autocommit = False
        print("🔄 Начинаем транзакцию")
        
        cursor.execute("SELECT id FROM products WHERE id = %s", (product_id,))
        if not cursor.fetchone():
            cursor.close()
            conn.close()
            return jsonify({
                'success': False,
                'error': 'Товар не найден'
            }), 404
        
        # Проверка на дубликаты по URL (кроме текущего товара)
        cursor.execute("""
            SELECT id FROM products 
            WHERE (aliexpress_link = %s OR (external_product_id = %s AND external_product_id IS NOT NULL))
            AND id != %s
        """, (data['aliexpress_link'], external_product_id, product_id))
        
        existing = cursor.fetchone()
        if existing:
            print(f"❌ Товар с таким URL уже существует: {existing[0]}")
            return jsonify({
                'success': False,
                'error': 'Товар с таким URL уже существует'
            }), 409
        
        # Обработка specifications
        #specifications = data.get('specifications')
        #safe_specifications = None
        #if specifications is not None:
            #if isinstance(specifications, dict):
                #safe_specifications = json.dumps(specifications)
            #elif isinstance(specifications, str):
                #try:
                    #json.loads(specifications)
                    #safe_specifications = specifications
                #except json.JSONDecodeError:
                    #print(f"⚠️ Некорректный JSON в specifications: {specifications}")
                    #safe_specifications = None
            #else:
                #print(f"⚠️ Некорректный тип specifications: {type(specifications)}")
                #safe_specifications = None
        
        # Безопасные функции преобразования
        def safe_float(value, default=0.0):
            if value is None or value == '' or value == 'None':
                return default
            try:
                return float(value)
            except (ValueError, TypeError):
                return default
        
        def safe_int(value, default=0):
            if value is None or value == '' or value == 'None':
                return default
            try:
                return int(float(value))
            except (ValueError, TypeError):
                return default
        
        def safe_str(value, default=''):
            if value is None or value == '' or value == 'None':
                return default
            if isinstance(value, (dict, list)):
                return json.dumps(value)
            return str(value)
        
        # Формирование запроса на обновление
        update_fields = [
            'title = %s',
            'ai_description = %s',
            'original_description = %s',
            'price = %s',
            'original_price = %s',
            'main_image = %s',
            'category = %s',
            'epn_link = %s',
            'aliexpress_link = %s',
            'rating = %s',
            'orders_count = %s',
            'external_product_id = %s',
            'updated_at = %s',
            'detailed_description = %s',
            'shipping_info = %s',
            'video_url = %s',
            'weight = %s',
            'dimensions = %s',
            'warranty_info = %s'
        ]
        
        update_params = [
            safe_str(data.get('title')),
            safe_str(data.get('ai_description')),
            safe_str(data.get('original_description')),
            safe_float(data.get('price'), 0),
            safe_float(data.get('original_price')) if data.get('original_price') else None,
            safe_str(data.get('main_image')),
            safe_str(data.get('category', categorize_product(data['title'], data.get('original_description', '')))),
            safe_str(data.get('epn_link')),
            safe_str(data.get('aliexpress_link')),
            safe_float(data.get('rating'), 0),
            safe_int(data.get('orders_count'), 0),
            safe_str(external_product_id),
            datetime.now(),
            safe_str(data.get('detailed_description')),
            safe_str(data.get('shipping_info')),
            safe_str(data.get('video_url')),
            safe_float(data.get('weight')) if data.get('weight') else None,
            safe_str(data.get('dimensions')),
            safe_str(data.get('warranty_info'))
        ]
        
        update_query = f"""
            UPDATE products 
            SET {', '.join(update_fields)}
            WHERE id = %s
        """
        update_params.append(product_id)
        
        print(f"🔄 Выполняем обновление товара {product_id}...")
        cursor.execute(update_query, update_params)
        
        # Обработка изображений
        images = data.get('images', [])
        if images:
            print(f"🖼️ Обновляем изображения для товара {product_id}: {len(images)} шт.")
            
            # Удаляем старые изображения
            #cursor.execute("DELETE FROM product_images WHERE product_id = %s", (product_id,))
            #print("🗑️ Старые изображения удалены")
            
            for i, image in enumerate(images):
                try:
                    image_url = None
                    if isinstance(image, str):
                        image_data = image.strip()
                    elif isinstance(image, dict):
                        image_data = image.get('image_url', '').strip()
                    else:
                        print(f"⚠️ Неизвестный тип изображения {i+1}")
                        continue
                    
                    if image_data.startswith('data:image/'):
                        print(f"📥 Изображение {i+1} в формате base64, сохраняем как файл...")
                        file_url, error = save_base64_image(image_data, product_id)
                        if error:
                            print(f"❌ Ошибка сохранения изображения {i+1}: {error}")
                            continue
                        image_url = file_url
                        print(f"✅ Изображение {i+1} сохранено как файл: {image_url}")
                    elif image_data.startswith(('http://', 'https://')):
                        print(f"🔗 Изображение {i+1} по URL: {image_data[:100]}...")
                        image_url = image_data
                    else:
                        print(f"⚠️ Изображение {i+1} имеет неизвестный формат, пропускаем")
                        continue
                    
                    if image_url:
                        print(f"🚀 Добавляем изображение {i+1} в БД")
                        cursor.execute("""
                            INSERT INTO product_images (product_id, image_url, is_main, sort_order, alt_text)
                            VALUES (%s, %s, %s, %s, %s)
                            RETURNING id
                        """, (
                            product_id,
                            image_url,
                            i == 0,
                            i,
                            safe_str(data.get('title', f'Image {i+1}'))
                        ))
                        image_id = cursor.fetchone()[0]
                        print(f"✅ Изображение {i+1} добавлено с ID {image_id}")
                except Exception as img_error:
                    print(f"❌ Ошибка при обработке изображения {i+1}: {img_error}")
                    continue
        
        print("💾 Коммитим транзакцию...")
        conn.commit()
        
        cursor.close()
        conn.close()
        
        print(f"✅ Товар ID {product_id} успешно обновлён")
        
        return jsonify({
            'success': True,
            'message': 'Товар успешно обновлён',
            'product_id': product_id
        })
    except Exception as e:
        print(f"❌ Ошибка при обновлении товара: {e}")
        import traceback
        traceback.print_exc()
        if conn:
            try:
                conn.rollback()
                print("🔄 Транзакция откачена")
            except:
                pass
        if cursor:
            cursor.close()
        if conn:
            conn.close()
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500



@app.route('/api/products/<int:product_id>', methods=['GET'])
def get_product_detail(product_id):
    """Получение детальной информации о товаре"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
        
        # Получение информации о товаре
        cursor.execute("""
            SELECT p.*, 
                   COALESCE(
                       (SELECT json_agg(
                           json_build_object(
                               'id', pi.id,
                               'image_url', pi.image_url,
                               'is_main', pi.is_main,
                               'sort_order', pi.sort_order,
                               'alt_text', pi.alt_text
                           ) ORDER BY pi.sort_order ASC, pi.id ASC
                       )
                       FROM product_images pi 
                       WHERE pi.product_id = p.id),
                       '[]'::json
                   ) as images
            FROM products p
            WHERE p.id = %s
        """, (product_id,))
        
        product = cursor.fetchone()
        
        if not product:
            cursor.close()
            conn.close()
            return jsonify({
                'success': False,
                'error': 'Товар не найден'
            }), 404
        
        # Получение статистики кликов
        cursor.execute("""
            SELECT SUM(clicks) as total_clicks
            FROM analytics
            WHERE product_id = %s
        """, (product_id,))
        
        stats = cursor.fetchone()
        total_clicks = stats['total_clicks'] if stats and stats['total_clicks'] else 0
        
        cursor.close()
        conn.close()
        
        product_data = {
            'id': product['id'],
            'title': product['title'],
            'ai_description': product['ai_description'],
            'original_description': product['original_description'],
            'detailed_description': product['detailed_description'],
            'price': float(product['price']) if product['price'] else 0,
            'original_price': float(product['original_price']) if product['original_price'] else None,
            'main_image': product['main_image'],
            'category': product['category'],
            'epn_link': product['epn_link'],
            'aliexpress_link': product['aliexpress_link'],
            'rating': float(product['rating']) if product['rating'] else 0,
            'orders_count': product['orders_count'] or 0,
            'status': product['status'],
            'created_at': product['created_at'].isoformat() if product['created_at'] else None,
            'specifications': product['specifications'],
            'shipping_info': product['shipping_info'],
            'video_url': product['video_url'],
            'weight': float(product['weight']) if product['weight'] else None,
            'dimensions': product['dimensions'],
            'warranty_info': product['warranty_info'],
            'images': json.loads(product['product_images_list']) if product.get('product_images_list') else [],
            'total_clicks': total_clicks
        }
        
        return jsonify({
            'success': True,
            'product': product_data
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/products/<int:product_id>/images', methods=['GET'])
def get_product_images_api(product_id):
    """Получение всех изображений товара"""
    try:
        images = get_product_images(product_id)
        
        return jsonify({
            'success': True,
            'images': images
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/products/<int:product_id>/images', methods=['POST'])
def add_product_image(product_id):
    """Добавление изображения к товару"""
    try:
        data = request.get_json()
        
        image_url = data.get('image_url')
        is_main = data.get('is_main', False)
        sort_order = data.get('sort_order', 0)
        alt_text = data.get('alt_text', '')
        
        if not image_url:
            return jsonify({
                'success': False,
                'error': 'image_url обязателен'
            }), 400
        
        if not validate_url(image_url):
            return jsonify({
                'success': False,
                'error': 'Неверный формат URL изображения'
            }), 400
        
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # Проверка существования товара
        cursor.execute("SELECT id FROM products WHERE id = %s", (product_id,))
        if not cursor.fetchone():
            cursor.close()
            conn.close()
            return jsonify({
                'success': False,
                'error': 'Товар не найден'
            }), 404
        
        # Если это главное изображение, убираем флаг у других
        if is_main:
            cursor.execute("""
                UPDATE product_images 
                SET is_main = FALSE 
                WHERE product_id = %s
            """, (product_id,))
        
        # Добавление изображения
        cursor.execute("""
            INSERT INTO product_images (product_id, image_url, is_main, sort_order, alt_text)
            VALUES (%s, %s, %s, %s, %s)
            RETURNING id
        """, (product_id, image_url, is_main, sort_order, alt_text))
        
        image_id = cursor.fetchone()[0]
        
        conn.commit()
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'message': 'Изображение успешно добавлено',
            'image_id': image_id
        }), 201
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/products/<int:product_id>/images/<int:image_id>', methods=['PUT'])
def update_product_image(product_id, image_id):
    """Обновление изображения товара"""
    try:
        data = request.get_json()
        
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # Проверка существования изображения
        cursor.execute("""
            SELECT id FROM product_images 
            WHERE id = %s AND product_id = %s
        """, (image_id, product_id))
        
        if not cursor.fetchone():
            cursor.close()
            conn.close()
            return jsonify({
                'success': False,
                'error': 'Изображение не найдено'
            }), 404
        
        # Если устанавливается главное изображение, убираем флаг у других
        if data.get('is_main'):
            cursor.execute("""
                UPDATE product_images 
                SET is_main = FALSE 
                WHERE product_id = %s
            """, (product_id,))
        
        # Обновление изображения
        update_fields = []
        params = []
        
        for field in ['image_url', 'is_main', 'sort_order', 'alt_text']:
            if field in data:
                update_fields.append(f"{field} = %s")
                params.append(data[field])
        
        if update_fields:
            params.extend([image_id, product_id])
            cursor.execute(f"""
                UPDATE product_images 
                SET {', '.join(update_fields)}
                WHERE id = %s AND product_id = %s
            """, params)
        
        conn.commit()
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'message': 'Изображение успешно обновлено'
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/products/<int:product_id>/images/<int:image_id>', methods=['DELETE'])
def delete_product_image(product_id, image_id):
    """Удаление изображения товара"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # Проверка существования изображения
        cursor.execute("""
            SELECT id FROM product_images 
            WHERE id = %s AND product_id = %s
        """, (image_id, product_id))
        
        if not cursor.fetchone():
            cursor.close()
            conn.close()
            return jsonify({
                'success': False,
                'error': 'Изображение не найдено'
            }), 404
        
        # Удаление изображения
        cursor.execute("""
            DELETE FROM product_images 
            WHERE id = %s AND product_id = %s
        """, (image_id, product_id))
        
        conn.commit()
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'message': 'Изображение успешно удалено'
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500







@app.route('/api/products/<int:product_id>', methods=['DELETE'])
def delete_product(product_id):
    """Удаление товара (мягкое удаление)"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # Проверка существования товара
        cursor.execute("SELECT id FROM products WHERE id = %s", (product_id,))
        if not cursor.fetchone():
            cursor.close()
            conn.close()
            return jsonify({
                'success': False,
                'error': 'Товар не найден'
            }), 404
        
        # Мягкое удаление (изменение статуса)
        cursor.execute("""
            UPDATE products 
            SET status = 'deleted', updated_at = %s
            WHERE id = %s
        """, (datetime.now(), product_id))
        
        conn.commit()
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'message': 'Товар успешно удален'
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/products/bulk', methods=['POST'])
def add_products_bulk():
    """Массовое добавление товаров"""
    try:
        data = request.get_json()
        products = data.get('products', [])
        
        if not products:
            return jsonify({
                'success': False,
                'error': 'Список товаров не может быть пустым'
            }), 400
        
        conn = get_db_connection()
        cursor = conn.cursor()
        
        added_count = 0
        errors = []
        
        for i, product in enumerate(products):
            try:
                # Валидация обязательных полей
                if not all(product.get(field) for field in ['title', 'price', 'aliexpress_link']):
                    errors.append(f'Товар {i+1}: отсутствуют обязательные поля')
                    continue
                
                # Валидация URL
                if not validate_url(product['aliexpress_link']):
                    errors.append(f'Товар {i+1}: неверный формат URL')
                    continue
                
                # Извлечение ID товара из URL
                product_id = extract_product_id_from_url(product['aliexpress_link'])
                
                # Проверка на дубликаты
                cursor.execute("""
                    SELECT id FROM products 
                    WHERE aliexpress_link = %s OR (external_product_id = %s AND external_product_id IS NOT NULL)
                """, (product['aliexpress_link'], product_id))
                
                if cursor.fetchone():
                    errors.append(f'Товар {i+1}: дубликат URL')
                    continue
                
                # Автоматическое определение категории
                category = product.get('category')
                if not category:
                    category = categorize_product(
                        product['title'],
                        product.get('original_description', '')
                    )
                
                # Обработка specifications
                specifications = product.get('specifications')
                if specifications:
                    if isinstance(specifications, dict):
                        specifications = json.dumps(specifications)
                    elif isinstance(specifications, str):
                        try:
                            json.loads(specifications)
                        except json.JSONDecodeError:
                            specifications = None
                    else:
                        specifications = None
                
                # Вставка товара
                insert_query = """
                    INSERT INTO products (
                        title, ai_description, original_description, detailed_description,
                        price, original_price, main_image, category, epn_link, aliexpress_link, 
                        rating, orders_count, external_product_id, status, created_at, updated_at,
                        specifications, shipping_info, video_url, weight, dimensions, warranty_info
                    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                    RETURNING id
                """
                
                cursor.execute(insert_query, (
                    product['title'],  # ✅ Исправлено: используем product вместо data
                    product.get('ai_description'),
                    product.get('original_description'),
                    product.get('detailed_description'),
                    float(product['price']),
                    float(product['original_price']) if product.get('original_price') else None,
                    product.get('main_image'),
                    category,
                    product.get('epn_link'),
                    product['aliexpress_link'],
                    float(product.get('rating', 0)),
                    int(product.get('orders_count', 0)),
                    product_id,
                    'active',
                    datetime.now(),
                    datetime.now(),
                    specifications,
                    product.get('shipping_info'),
                    product.get('video_url'),
                    float(product.get('weight')) if product.get('weight') else None,
                    product.get('dimensions'),
                    product.get('warranty_info')
                ))
                
                new_product_id = cursor.fetchone()[0]
                
                # Добавление дополнительных изображений
                additional_images = product.get('additional_images', [])
                if additional_images:
                    for idx, image_data in enumerate(additional_images):
                        if validate_url(image_data.get('image_url', '')):
                            cursor.execute("""
                                INSERT INTO product_images (product_id, image_url, is_main, sort_order, alt_text)
                                VALUES (%s, %s, %s, %s, %s)
                            """, (
                                new_product_id,
                                image_data['image_url'],
                                image_data.get('is_main', False),
                                image_data.get('sort_order', idx),
                                image_data.get('alt_text', '')
                            ))
                
                added_count += 1
                
            except Exception as e:
                errors.append(f'Товар {i+1}: {str(e)}')
        
        conn.commit()
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'message': f'Обработано товаров: {len(products)}, добавлено: {added_count}',
            'added_count': added_count,
            'errors': errors
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500


@app.route('/api/categories', methods=['GET'])
def get_categories():
    """Получение списка категорий"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
        
        cursor.execute("""
            SELECT category, COUNT(*) as count
            FROM products 
            WHERE status = 'active'
            GROUP BY category
            ORDER BY count DESC
        """)
        
        categories = [{'name': row['category'], 'count': row['count']} 
                     for row in cursor.fetchall()]
        
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'categories': categories
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/analytics/click', methods=['POST'])
def track_click():
    """Трекинг кликов по товарам"""
    try:
        data = request.get_json()
        product_id = data.get('product_id')
        source = data.get('source', 'website')
        
        if not product_id:
            return jsonify({'success': False, 'error': 'product_id is required'}), 400
        
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # Проверяем, есть ли уже запись для этого товара сегодня
        cursor.execute("""
            SELECT id FROM analytics 
            WHERE product_id = %s AND date = CURRENT_DATE AND source = %s
        """, (product_id, source))
        
        existing = cursor.fetchone()
        
        if existing:
            # Увеличиваем счетчик кликов
            cursor.execute("""
                UPDATE analytics 
                SET clicks = clicks + 1 
                WHERE id = %s
            """, (existing[0],))
        else:
            # Создаем новую запись
            cursor.execute("""
                INSERT INTO analytics (product_id, clicks, source, date) 
                VALUES (%s, 1, %s, CURRENT_DATE)
            """, (product_id, source))
        
        conn.commit()
        cursor.close()
        conn.close()
        
        return jsonify({'success': True})
        
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/stats', methods=['GET'])
def get_stats():
    """Получение статистики"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
        
        # Общая статистика
        cursor.execute("""
            SELECT 
                COUNT(*) as total_products,
                COUNT(CASE WHEN status = 'active' THEN 1 END) as active_products,
                COUNT(CASE WHEN created_at::date = CURRENT_DATE THEN 1 END) as today_products
            FROM products
        """)
        
        stats = cursor.fetchone()
        
        # Статистика по категориям
        cursor.execute("""
            SELECT category, COUNT(*) as count
            FROM products 
            WHERE status = 'active'
            GROUP BY category
            ORDER BY count DESC
        """)
        
        categories = [{'category': row['category'], 'count': row['count']} 
                     for row in cursor.fetchall()]
        
        # Статистика кликов за последние 7 дней
        cursor.execute("""
            SELECT DATE(date) as date, SUM(clicks) as clicks
            FROM analytics
            WHERE date >= CURRENT_DATE - INTERVAL '7 days'
            GROUP BY DATE(date)
            ORDER BY date
        """)
        
        clicks_data = [{'date': row['date'].isoformat(), 'clicks': row['clicks']} 
                      for row in cursor.fetchall()]
        
        # Статистика изображений
        cursor.execute("""
            SELECT COUNT(*) as total_images,
                   COUNT(DISTINCT product_id) as products_with_images
            FROM product_images
        """)
        
        images_stats = cursor.fetchone()
        
        cursor.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'stats': {
                'total_products': stats['total_products'],
                'active_products': stats['active_products'],
                'today_products': stats['today_products'],
                'categories': categories,
                'clicks_last_7_days': clicks_data,
                'total_images': images_stats['total_images'],
                'products_with_images': images_stats['products_with_images']
            }
        })
        
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/health', methods=['GET'])
def health_check():
    """Проверка работоспособности API"""
    return jsonify({
        'success': True,
        'message': 'API работает корректно',
        'timestamp': datetime.now().isoformat()
    })

@app.route('/api/parser/start', methods=['POST'])
def start_parser():
    """Запуск парсера с официальным API AliExpress"""
    try:
        data = request.get_json()
        search_queries = data.get('queries', [])
        max_pages = data.get('max_pages', 1)
        
        if not search_queries:
            return jsonify({
                'success': False,
                'error': 'Не указаны поисковые запросы'
            }), 400
        
        # Валидация запросов
        if isinstance(search_queries, str):
            search_queries = [q.strip() for q in search_queries.split('\n') if q.strip()]
        
        print(f"🎯 Запуск API парсера для {len(search_queries)} запросов")
        print(f"📝 Запросы: {search_queries}")
        
        import threading
        
        def run_api_parser():
            try:
                # Импортируем конфигурацию
                from config import ALIEXPRESS_APP_KEY, ALIEXPRESS_APP_SECRET
                from aliexpress_api_parser import AliExpressAPIParser
                
                print(f"🔑 Инициализация API парсера...")
                parser = AliExpressAPIParser(ALIEXPRESS_APP_KEY, ALIEXPRESS_APP_SECRET)
                
                max_products = min(max_pages * 3, 10)  # Ограничиваем количество
                print(f"📊 Максимум товаров на запрос: {max_products}")
                
                products = parser.parse_and_save(search_queries, max_products_per_query=max_products)
                print(f"🎉 API парсинг завершен! Добавлено товаров: {len(products)}")
                    
            except ImportError as e:
                print(f"❌ Ошибка импорта: {e}")
                print("🔧 Проверьте, что файлы config.py и aliexpress_api_parser.py существуют")
            except Exception as e:
                print(f"❌ Ошибка в API парсере: {e}")
                import traceback
                traceback.print_exc()
        
        # Запускаем парсер в отдельном потоке
        thread = threading.Thread(target=run_api_parser)
        thread.daemon = True
        thread.start()
        
        return jsonify({
            'success': True,
            'message': f'API парсинг запущен для {len(search_queries)} запросов. Используется официальный API AliExpress с вашими ключами!'
        })
        
    except Exception as e:
        print(f"❌ Ошибка запуска API парсера: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500


@app.route('/api/parser/queries', methods=['GET'])
def get_parser_queries():
    """Получение предустановленных запросов для парсинга"""
    queries = {
        'camping': [
            "camping solar panel",
            "rv battery 12v",
            "portable camping stove",
            "camping mattress inflatable"
        ],
        'electronics': [
            "car inverter 12v 220v",
            "led strip 12v",
            "car charger usb",
            "portable power bank"
        ],
        'tools': [
            "car tire pump",
            "emergency car kit",
            "car jump starter",
            "automotive tools set"
        ]
    }
    
    return jsonify({
        'success': True,
        'queries': queries
    })

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=6000)