ошибка export_rpa
GET http://192.168.50.110/export_rpa_excel 500 (INTERNAL SERVER ERROR)
(anonymous) @ table.js:901
dispatch @ jquery-3.6.0.min.js:2
v.handle @ jquery-3.6.0.min.js:2
table.js:920 Error: Error: Network response was not ok.
    at table.js:906:19

from flask import Flask, render_template, request, redirect, make_response, jsonify, send_file, Response
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.sql import func
from datetime import datetime, timedelta, date, timezone
import pandas as pd
from io import BytesIO
import json
import queue
import logging
from sqlalchemy import cast, Integer, or_
import os
from collections import deque
import random
import subprocess
import platform
import paramiko 




app = Flask(__name__)



app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///table_data.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

ACTIVITY_HISTORY_LENGTH = 400  # Количество последних значений для графика
activity_data = {}

class TableRow(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    date = db.Column(db.String(10), nullable=False)
    row_number = db.Column(db.String(10))
    timestamp = db.Column(db.String(50))
    number = db.Column(db.String(50), unique=True)
    serial = db.Column(db.String(50), unique=True)
    dl_number = db.Column(db.String(50))
    worker_name = db.Column(db.String(100))
    pack_time = db.Column(db.String(50))
    arma_type = db.Column(db.String(50))
    dateshipment = db.Column(db.String(50))
    aktshipment = db.Column(db.String(50))
    bad_recovery = db.Column(db.Boolean, default=False)



class DLCounter(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    date = db.Column(db.String(10), unique=True, nullable=False)
    counter = db.Column(db.Integer, nullable=False)

    def __repr__(self):
        return f'<DLCounter {self.date}: {self.counter}>'


class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    login_history = db.relationship('LoginHistory', backref='user', lazy=True)


class LoginHistory(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    login_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)

class Statistics(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    date = db.Column(db.String(10), unique=True, nullable=False)
    generate_clicks = db.Column(db.Integer, default=0)
    pack_clicks = db.Column(db.Integer, default=0)

    def __repr__(self):
        return f'<Statistics {self.date}: Generate={self.generate_clicks}, Pack={self.pack_clicks}>'

# Добавьте это в раздел моделей вашего Flask-приложения

class Device(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(10), unique=True, nullable=False)  # Имена: ARM1, ARM2 и т.д.
    arma_type = db.Column(db.String(10), nullable=False, default='Other')  # Тип АРМА
    last_active = db.Column(db.DateTime, nullable=True)  # Время последней активности
    internet_up = db.Column(db.Boolean, nullable=False, default=True)  # Статус интернет-соединения
    copying = db.Column(db.Boolean, nullable=False, default=False)  # Статус копирования
    previous_copying = db.Column(db.Boolean, nullable=False, default=False)  # Новое поле
    sending_number = db.Column(db.Boolean, nullable=False, default=False)  # Статус отправки номера
    processing = db.Column(db.Boolean, nullable=False, default=False)  # Новое поле для активности activationGlaz.py

    def to_dict(self, current_time=None):
        if current_time is None:
            current_time = datetime.utcnow()
        if self.copying:
            status = 'copying'
        elif self.sending_number:
            status = 'sending_number'
        else:
            status = 'offline'
            if self.last_active:
                delta = current_time - self.last_active
                if delta <= timedelta(seconds=60):
                    if self.internet_up:
                        status = 'online'
                    else:
                        status = 'no_internet'
        return {
            "id": self.id,
            "name": self.name,
            "arma_type": self.arma_type,
            "last_active": self.last_active.isoformat() if self.last_active else None,
            "internet_up": self.internet_up,
            "copying": self.copying,
            "sending_number": self.sending_number,
            "status": status
        }
    
    def get_status(self, current_time=None):
        if current_time is None:
            current_time = datetime.utcnow()

        if self.copying:
            return 'copying'
        elif self.sending_number:
            return 'sending_number'
        elif self.name == 'ARM3':
            # Для ARM3 игнорируем статус 'processing'
            if self.last_active:
                delta = current_time - self.last_active
                threshold = timedelta(seconds=5)
                if delta <= threshold:
                    if self.internet_up:
                        return 'online'
                    else:
                        return 'no_internet'
            return 'offline'
        elif self.processing:
            return 'processing'
        else:
            if self.last_active:
                delta = current_time - self.last_active
                threshold = timedelta(seconds=5)
                if delta <= threshold:
                    if self.internet_up:
                        return 'online'
                    else:
                        return 'no_internet'
            return 'offline'




tables = {}
table = [['№', 'Время отправки', 'Номер ', 'Serial', 'Графа', 'Имя отправителя','Время упаковки' ,'Тип АРМА',  'Дата отгрузки',  'Номер Акта', 'Bad Recovery',  'Действие']]
# Создаем очередь для событий
update_queue = queue.Queue()
previous_processing_states = {}

@app.route('/get_device_status', methods=['GET'])
def get_device_status():
    devices = Device.query.all()
    device_statuses = {}
    threshold = timedelta(seconds=5)  # Reduced time threshold for quick offline detection
    now = datetime.utcnow()

    for device in devices:
        name = device.name

        # Retrieve the previous processing state
        prev_processing = previous_processing_states.get(name, False)

        # Check if last_active is within the threshold
        is_recent = device.last_active and now - device.last_active <= threshold

        if device.sending_number:
            status = 'sending_number'
            activity_value = random.choice([2, 3, 2, 3, 4, 3, 2])
        elif device.copying:
            status = 'copying'
            activity_value = random.choice([0, 1, 0, 1, 2, 1, 0])
        elif is_recent:
            if device.internet_up:
                status = 'online'
                activity_value = 1
            else:
                status = 'no_internet'
                activity_value = 0

            # Handle processing status
            if device.processing:
                if device.name == 'ARM3':
                    if not prev_processing:
                        # Processing started on ARM3, send a single impulse
                        activity_value = 5  # Single impulse
                        status = 'online'  # Keep status as online for ARM3
                else:
                    status = 'processing'
                    activity_value = random.choice([2, 3, 2, 3, 4, 3, 2])
        else:
            status = 'offline'
            activity_value = 0

        device_statuses[name] = {
            'status': status,
            'processing': device.processing
        }
        activity_data[name].append(activity_value)
        logging.debug(f"Device {name}: status {status}, activity {activity_value}")

        # Update previous_processing_states
        previous_processing_states[name] = device.processing

    # Convert activity_data to serializable format
    activity_data_serializable = {name: list(data) for name, data in activity_data.items()}

    device_statuses = {
        'ARM1': {'status': 'offline'}
        # Add more devices here if needed
    }


    return jsonify({
        'status': 'success',
        'devices': device_statuses,
        'activity': activity_data_serializable
    })


@app.route('/set_dl_prefix', methods=['POST'])
def set_dl_prefix():
    data = request.json
    new_prefix = data.get('prefix')

    if not new_prefix:
        return jsonify({"status": "error", "message": "Prefix is required"}), 400

    app.config['DL_PREFIX'] = new_prefix  # Update the prefix
    return jsonify({"status": "success", "new_prefix": new_prefix})




def initialize_activity_data():
    device_names = ['ARM1', 'ARM2', 'ARM3', 'ARM4', 'ARM5', 'ARM6']
    for name in device_names:
        activity_data[name] = deque([0]*ACTIVITY_HISTORY_LENGTH, maxlen=ACTIVITY_HISTORY_LENGTH)

def create_devices():
    device_types = {
        'ARM1': 'CFA',
        'ARM2': 'VND',
        'ARM3': 'SRC',
        'ARM4': 'SRC',
        'ARM5': 'RPA',
        'ARM6': 'RPA'  # Убедитесь, что ARM6 тоже имеет тип 'RPA'
    }
    for name, arma_type in device_types.items():
        device = Device.query.filter_by(name=name).first()
        if not device:
            device = Device(name=name, arma_type=arma_type, sending_number=False)
            db.session.add(device)
    db.session.commit()
    initialize_activity_data()

@app.route('/register_user', methods=['POST'])
def register_user():
    data = request.json
    worker_name = data.get('worker_name')
    internet_up = data.get('internet_up', False)
    copying = data.get('copying', False)
    sending_number = data.get('sending_number', False)
    processing = data.get('processing', False)  # Новое поле

    if not worker_name:
        return jsonify({"status": "error", "message": "worker_name is required"}), 400

    device = Device.query.filter_by(name=worker_name).first()
    if not device:
        return jsonify({"status": "error", "message": "Device not found"}), 404

    device.last_active = datetime.utcnow()
    device.internet_up = internet_up
    device.copying = copying
    device.sending_number = sending_number
    device.processing = processing  # Сохраняем новое поле
    db.session.commit()

    return jsonify({"status": "success"})

@app.route('/get_unpacked_days', methods=['GET'])
def get_unpacked_days():
    year = request.args.get('year')
    month = request.args.get('month')
    
    if not year or not month:
        return jsonify({"status": "error", "message": "Необходимо указать год и месяц"}), 400
    
    try:
        year = int(year)
        month = int(month)
    except ValueError:
        return jsonify({"status": "error", "message": "Год и месяц должны быть числами"}), 400

    # Формируем формат даты для фильтрации
    month_str = f"{month:02d}"
    
    # Запрашиваем уникальные дни, где pack_time отсутствует и arma_type равен 'RPA'
    unpacked_dates = TableRow.query.filter(
        TableRow.date.like(f"{year}-{month_str}-%"),
        TableRow.arma_type == 'RPA',
        or_(TableRow.pack_time == None, TableRow.pack_time == '')
    ).with_entities(TableRow.date).distinct().all()
    
    # Извлекаем дни из дат
    unpacked_days = set()
    for date_str, in unpacked_dates:
        try:
            day = int(date_str.split('-')[2])
            unpacked_days.add(day)
        except (IndexError, ValueError):
            continue  # Пропускаем некорректные форматы дат

    return jsonify({'status': 'success', 'unpacked_days': list(unpacked_days)})

@app.route('/stream')
def stream():
    def event_stream():
        while True:
            try:
                data = update_queue.get(timeout=20)
                yield f'data: {data}\n\n'
            except queue.Empty:
                yield ': keep-alive\n\n'
    return Response(event_stream(), mimetype='text/event-stream')


# Удален маршрут /ping, так как он использовал ActiveUser


@app.route('/get_table_data')
def get_table_data():
    date = request.args.get('date')
    filter_arma = request.args.get('filter_arma')

    app.logger.debug(f"Получен запрос таблицы для даты: {date}, фильтр: {filter_arma}")

    query = TableRow.query.filter_by(date=date)

    if filter_arma == 'RPA':
        query = query.filter_by(arma_type='RPA')

    rows = query.all()
    app.logger.debug(f"Найдено записей: {len(rows)} для даты {date} с фильтром {filter_arma}")

    data = []
    numbers = {}
    serials = {}
    dl_numbers = {}

    for row in rows:
        has_duplicate = False

        if row.number:
            clean_number = ''.join(filter(str.isdigit, row.number))
            if clean_number in numbers:
                has_duplicate = True
            else:
                numbers[clean_number] = row.id

        if row.serial:
            clean_serial = ''.join(filter(str.isdigit, row.serial))
            if clean_serial in serials:
                has_duplicate = True
            else:
                serials[clean_serial] = row.id

        if row.dl_number:
            clean_dl_number = ''.join(filter(str.isdigit, row.dl_number))
            if clean_dl_number in dl_numbers:
                has_duplicate = True
            else:
                dl_numbers[clean_dl_number] = row.id

        data.append({
            'id': row.id,
            'row_number': row.row_number,
            'timestamp': row.timestamp,
            'number': row.number,
            'serial': row.serial,
            'dl_number': row.dl_number,
            'worker_name': row.worker_name,
            'pack_time': row.pack_time,
            'arma_type': row.arma_type,
            'dateshipment': row.dateshipment,
            'aktshipment': row.aktshipment,
            'bad_recovery': has_duplicate
        })

    return jsonify({
        "data": data,
    })



@app.route('/update_table', methods=['POST'])
def update_table():
    data = request.json
    date = data['date']
    worker_name = data['worker_name']
    arma_type = data['arma_type']

    # Проверка на дубликаты перед добавлением новой записи
    if 'number' in data and data['number']:
        existing_entry = TableRow.query.filter_by(number=data['number']).first()
        if existing_entry:
            return jsonify({"status": "error", "message": "Дублирование номера"}), 400

    if 'serial' in data and data['serial']:
        existing_entry = TableRow.query.filter_by(serial=data['serial']).first()
        if existing_entry:
            return jsonify({"status": "error", "message": "Дублирование серийного номера"}), 400

    # Получаем количество существующих записей для этой даты
    row_count = TableRow.query.filter_by(date=date).count() + 1

    # Создаём новую строку в таблице
    new_row = TableRow(
        date=date,
        row_number=str(row_count),
        timestamp=data['timestamp'],
        number=data.get('number', ''),
        serial=data.get('serial', ''),
        dl_number=data.get('dl_number', ''),
        worker_name=worker_name,
        pack_time=data.get('pack_time', ''),
        arma_type=arma_type,
        dateshipment=data.get('dateshipment', ''),
        aktshipment=data.get('aktshipment', ''),
        bad_recovery=data.get('bad_recovery', False)
    )

    # Сохраняем запись в базе данных
    db.session.add(new_row)

    device = Device.query.filter_by(name=worker_name).first()
    if device:
        device.last_active = datetime.utcnow()
    db.session.commit()

    # Проверка на дубликаты после добавления новой записи
    duplicates = check_for_duplicates()

    # Отправляем сообщение в очередь для обновления клиентов
    update_queue.put(json.dumps({"type": "update", "date": date}))

    return jsonify({"status": "success", "duplicates": duplicates})

def check_for_duplicates():
    rows = TableRow.query.all()
    numbers = {}
    serials = {}
    dl_numbers = {}

    for row in rows:
        if row.number:
            clean_number = ''.join(filter(str.isdigit, row.number))
            if clean_number in numbers:
                numbers[clean_number].append(row.id)
            else:
                numbers[clean_number] = [row.id]

        if row.serial:
            clean_serial = ''.join(filter(str.isdigit, row.serial))
            if clean_serial in serials:
                serials[clean_serial].append(row.id)
            else:
                serials[clean_serial] = [row.id]

        if row.dl_number:
            clean_dl_number = ''.join(filter(str.isdigit, row.dl_number))
            if clean_dl_number in dl_numbers:
                dl_numbers[clean_dl_number].append(row.id)
            else:
                dl_numbers[clean_dl_number] = [row.id]

    duplicate_numbers = {k: v for k, v in numbers.items() if len(v) > 1}
    duplicate_serials = {k: v for k, v in serials.items() if len(v) > 1}
    duplicate_dl_numbers = {k: v for k, v in dl_numbers.items() if len(v) > 1}

    return {
        "numbers": duplicate_numbers,
        "serials": duplicate_serials,
        "dl_numbers": duplicate_dl_numbers
    }


@app.route('/update_graf', methods=['POST'])
def update_graf():
    try:
        data = request.json
        row_id = int(data.get('id'))
        new_value = data.get('new_value')
        date = data.get('date')

        if not row_id or not date:
            return jsonify({"status": "error", "message": "Missing 'id' or 'date' in request"}), 400

        # Находим запись по id и дате
        row = TableRow.query.filter_by(id=row_id, date=date).first()
        if row:
            row.dl_number = new_value
            db.session.commit()
            return jsonify({"status": "success"})
        else:
            return jsonify({"status": "error", "message": "Row not found"}), 404
    except (ValueError, TypeError) as e:
        return jsonify({"status": "error", "message": f"Invalid input: {str(e)}"}), 400
    except Exception as e:
        db.session.rollback()
        return jsonify({"status": "error", "message": str(e)}), 500


@app.route('/update_arma_type', methods=['POST'])
def update_arma_type():
    try:
        data = request.json
        date = data['date']
        serial = data['serial']
        arma_type = data['arma_type']

        row = TableRow.query.filter_by(date=date, serial=serial).first()
        if row:
            row.arma_type = arma_type
            db.session.commit()
            return jsonify({"status": "success"})
        else:
            return jsonify({"status": "error", "message": "Row not found"})
    except Exception as e:
        return jsonify({"status": "error", "message": str(e)})


@app.route('/update_number', methods=['POST'])
def update_number():
    try:
        data = request.json
        row_id = int(data['id'])  # Используем 'id' вместо 'row_index'
        new_value = data['new_value']
        date = data['date']

        # Находим запись по id и дате
        row = TableRow.query.filter_by(id=row_id, date=date).first()
        if row:
            row.number = new_value
            db.session.commit()
            return jsonify({"status": "success"})
        return jsonify({"status": "error", "message": "Row not found"})
    except Exception as e:
        db.session.rollback()
        return jsonify({"status": "error", "message": str(e)})

@app.route('/pack_item', methods=['POST'])
def pack_item():
    try:
        data = request.json
        row_id = data['id']
        date = data['date']

        rows = TableRow.query.filter_by(id=row_id, date=date).all()
        if rows:
            row = rows[0]
            pack_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            row.pack_time = pack_time
            db.session.commit()
            
            # Обновляем статистику упаковки
            statistics = Statistics.query.filter_by(date=date).first()
            if statistics:
                statistics.pack_clicks += 1
            else:
                statistics = Statistics(date=date, generate_clicks=0, pack_clicks=1)  # pack_clicks=1
                db.session.add(statistics)
            db.session.commit()
            
            # Отправляем сообщение в очередь для обновления клиентов
            update_queue.put(json.dumps({"type": "update", "date": date}))
            
            return jsonify({"status": "success", "pack_time": pack_time})

        return jsonify({"status": "error", "message": "Строка не найдена"}), 404
    except Exception as e:
        print(f"Ошибка в pack_item: {str(e)}")
        return jsonify({"status": "error", "message": str(e)}), 500



@app.route('/set_initial_dl', methods=['POST'])
def set_initial_dl():
    try:
        data = request.json
        if not data:
            return jsonify({"status": "error", "message": "No data received"})

        date = data.get('date')
        initial_number = data.get('initial_number')

        if not date or not initial_number:
            return jsonify({
                "status": "error", 
                "message": "Missing required fields",
                "received": {"date": date, "initial_number": initial_number}
            })

        try:
            initial_number = int(initial_number)
        except ValueError:
            return jsonify({
                "status": "error",
                "message": "Initial number must be an integer"
            })

        print(f"Setting initial DL for date {date}: {initial_number}")  # Отладочный вывод

        dl_counter = DLCounter.query.filter_by(date=date).first()
        if dl_counter:
            dl_counter.counter = initial_number
            print(f"Updated existing counter for {date}")  # Отладочный вывод
        else:
            dl_counter = DLCounter(date=date, counter=initial_number)
            db.session.add(dl_counter)
            print(f"Created new counter for {date}")  # Отладочный вывод

        db.session.commit()
        return jsonify({
            "status": "success",
            "message": f"DL counter set to {initial_number} for date {date}"
        })

    except Exception as e:
        print(f"Error in set_initial_dl: {str(e)}")  # Отладочный вывод
        db.session.rollback()
        return jsonify({
            "status": "error",
            "message": str(e)
        })


@app.route('/generate_dl', methods=['POST'])
def generate_dl():
    try:
        data = request.json
        row_id = data['id']
        date = data['date']

        # Получаем или создаем счетчик DL для данной даты
        dl_counter = DLCounter.query.filter_by(date=date).first()
        if not dl_counter:
            return jsonify({"status": "error", "message": "DL counter не инициализирован"}), 400

        # Генерируем новый DL номер с использованием префикса
        dl_prefix = app.config['DL_PREFIX']  # Получаем префикс из конфигурации
        dl_number = f"{dl_prefix}{dl_counter.counter:06d}"

        # Находим и обновляем нужную запись по id
        row = TableRow.query.filter_by(id=row_id, date=date).first()
        if row:
            row.dl_number = dl_number
            dl_counter.counter += 1  # Увеличиваем счетчик

            # Обновляем статистику генерации
            statistics = Statistics.query.filter_by(date=date).first()
            if statistics:
                statistics.generate_clicks += 1
            else:
                statistics = Statistics(date=date, generate_clicks=1, pack_clicks=0)
                db.session.add(statistics)

            db.session.commit()
            return jsonify({"status": "success", "dl_number": dl_number, "id": row_id})

        return jsonify({"status": "error", "message": "Строка не найдена"}), 404
    except Exception as e:
        return jsonify({"status": "error", "message": str(e)}), 500




@app.route('/export_excel')
def export_excel():
    try:
        date = request.args.get('date')
        sort_column = request.args.get('sort_column')
        sort_order = request.args.get('sort_order')

        if not date:
            return jsonify({"error": "Date parameter is required"}), 400

        # Начинаем построение запроса с фильтрации по дате и типу АРМА "RPA"
        query = TableRow.query.filter_by(date=date, arma_type='RPA')

        # Добавляем дополнительные условия фильтрации:
        # - dl_number не пустой
        # - pack_time не пустой
        query = query.filter(
            TableRow.dl_number.isnot(None),
            TableRow.dl_number != '',
            TableRow.pack_time.isnot(None),
            TableRow.pack_time != ''
        )

        # Применяем сортировку, если указана
        if sort_column and sort_order:
            column_mapping = {
                '0': TableRow.row_number,
                '1': TableRow.timestamp,
                '2': TableRow.number,
                '3': TableRow.serial,
                '4': TableRow.dl_number,
                '5': TableRow.worker_name,
                '6': TableRow.pack_time,  # Время упаковки
                '7': TableRow.arma_type,  # Тип АРМА
                '8': TableRow.dateshipment,  # Дата отгрузки
                '9': TableRow.aktshipment,  # Номер Акта
                '10': TableRow.bad_recovery,
            }
            if sort_column in column_mapping:
                column = column_mapping[sort_column]

                # Явно приводим столбец "Номер" к целому числу для корректной сортировки
                if sort_column == '2':
                    column = cast(column, Integer)

                if sort_order == 'desc':
                    query = query.order_by(column.desc())
                else:
                    query = query.order_by(column.asc())
            else:
                return jsonify({"error": "Invalid sort column"}), 400

        rows = query.all()

        # Создаем DataFrame только с отфильтрованными данными
        data = []
        for row in rows:
            # Безопасное преобразование номера
            try:
                number = int(row.number) if row.number and row.number.strip() else None
            except ValueError:
                number = None

            data.append({
                '№': row.row_number,
                'Время отправки': row.timestamp,
                'Номер': number,
                'Serial': row.serial,
                'Графа': row.dl_number,
                'Имя отправителя': row.worker_name,
                'Время упаковки': row.pack_time,  # Время упаковки
                'Тип АРМА': row.arma_type,  # Тип АРМА
                'Дата отгрузки': row.dateshipment,  # Тип АРМА
                'Номер акта': row.aktshipment,  # Тип АРМА
                'bad_recovery':row.bad_recovery,
            })

        if not data:
            return jsonify({"error": "Нет записей для экспорта с заданными критериями."}), 400

        df = pd.DataFrame(data)

        # Создаем Excel файл
        output = BytesIO()
        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
            df.to_excel(writer, index=False, sheet_name='Sheet1')

            # Настраиваем форматирование
            workbook = writer.book
            worksheet = writer.sheets['Sheet1']

            # Автоматическая ширина столбцов
            for idx, col in enumerate(df.columns):
                series = df[col]
                max_len = max(
                    series.astype(str).map(len).max(),
                    len(str(col))
                ) + 2
                worksheet.set_column(idx, idx, max_len)

                # Форматирование числовых столбцов
                if col in ['Номер', 'Графа']:
                    num_format = workbook.add_format({'num_format': '0'})
                    worksheet.set_column(idx, idx, max_len, num_format)

        output.seek(0)

        return send_file(
            output,
            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            as_attachment=True,
            download_name=f'export_{date}.xlsx'
        )

    except Exception as e:
        print(f"Export error: {str(e)}")
        return jsonify({"error": str(e)}), 500


@app.route('/update_serial', methods=['POST'])
def update_serial():
    try:
        data = request.json
        row_index = int(data['row_index'])
        new_value = data['new_value']
        date = data['date']

        rows = TableRow.query.filter_by(date=date).all()
        if 0 <= row_index < len(rows):
            row = rows[row_index]
            row.serial = new_value
            db.session.commit()
            return jsonify({"status": "success"})
        return jsonify({"status": "error", "message": "Invalid row index"})
    except Exception as e:
        db.session.rollback()
        return jsonify({"status": "error", "message": str(e)})


def initialize_table_for_date(date):
    # Проверяем, существуют ли уже записи для этой даты
    existing = TableRow.query.filter_by(date=date).first()
    if not existing:
        # Создаем новую запись только в случае отсутствия данных
        new_row = TableRow(
            date=date,
            row_number=str(1),
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            number='',
            serial='',
            dl_number='',
            worker_name='',
            arma_type='',
            pack_time='',
            dateshipment='',
            aktshipment='',
            bad_recovery='',
        )
        db.session.add(new_row)
        
        # Инициализируем статистику для новой даты
        statistics = Statistics(date=date, generate_clicks=0, pack_clicks=0)
        db.session.add(statistics)
        
        db.session.commit()


@app.route('/update_serial_arma', methods=['POST'])
def update_serial_arma():
    try:
        data = request.json
        date = data['date']
        serial = data['serial']
        arma_type = data['arma_type']

        # Создаем новую запись в таблице
        new_row = TableRow(
            date=date,
            serial=serial,
            arma_type=arma_type,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )

        db.session.add(new_row)
        db.session.commit()

        return jsonify({"status": "success"})
    except Exception as e:
        db.session.rollback()
        return jsonify({"status": "error", "message": str(e)}), 500

@app.route('/get_statistics')
def get_statistics():
    try:
        date = request.args.get('date')
        app.logger.debug(f"Получен запрос статистики для даты: {date}")
        
        # Получаем статистику генерации и упаковки
        statistics = Statistics.query.filter_by(date=date).first()
        if not statistics:
            generate_clicks = 0
            pack_clicks = 0
            app.logger.debug(f"Статистика для даты {date} не найдена. Установлено значение 0.")
        else:
            generate_clicks = statistics.generate_clicks
            pack_clicks = statistics.pack_clicks
            app.logger.debug(f"Статистика для даты {date}: Генераций = {generate_clicks}, Упаковок = {pack_clicks}")
        
        # Получаем количество записей типа "RPA"
        rpa_records = TableRow.query.filter_by(date=date, arma_type='RPA').count()
        app.logger.debug(f"Количество записей типа RPA для даты {date}: {rpa_records}")
        
        # Считаем количество записей "RPA" без значения в колонке "Графа"
        unpacked_clicks = TableRow.query.filter(
            TableRow.date == date,
            TableRow.arma_type == 'RPA',
            TableRow.dl_number == None
        ).count()
        
        # Получаем количество упакованных записей за текущий час
        current_hour = datetime.now().replace(minute=0, second=0, microsecond=0)
        next_hour = current_hour + timedelta(hours=1)
        done_per_hour = TableRow.query.filter(
            TableRow.date == date,
            TableRow.arma_type == 'RPA',
            TableRow.pack_time >= current_hour,
            TableRow.pack_time < next_hour
        ).count()
        
        return jsonify({
            "generate_clicks": generate_clicks,
            "pack_clicks": pack_clicks,
            "rpa_records": rpa_records,
            "unpacked_clicks": unpacked_clicks,
            "done_per_hour": done_per_hour
        })
    except Exception as e:
        app.logger.error(f"Ошибка в get_statistics: {str(e)}")
        return jsonify({
            "generate_clicks": 0,
            "pack_clicks": 0,
            "rpa_records": 0,
            "unpacked_clicks": 0,
            "done_per_hour": 0,
            "error": str(e)
        })
@app.route('/delete_row', methods=['POST'])
def delete_row():
    try:
        data = request.json
        row_id = data.get('id')

        if not row_id:
            return jsonify({'status': 'error', 'message': 'ID записи не предоставлен'}), 400

        row = TableRow.query.get(row_id)
        if not row:
            return jsonify({'status': 'error', 'message': 'Запись не найдена'}), 404

        date = row.date  # Получаем дату записи для обновления статистики

        # Получаем запись статистики для этой даты
        statistics = Statistics.query.filter_by(date=date).first()

        if statistics:
            # Если запись имела сгенерированный DL номер, уменьшаем generate_clicks
            if row.dl_number:
                if statistics.generate_clicks > 0:
                    statistics.generate_clicks -= 1
                else:
                    app.logger.warning(f"Attempting to decrement generate_clicks below zero for date {date}")

            # Если запись была упакована, уменьшаем pack_clicks
            if row.pack_time:
                if statistics.pack_clicks > 0:
                    statistics.pack_clicks -= 1
                else:
                    app.logger.warning(f"Attempting to decrement pack_clicks below zero for date {date}")

            db.session.commit()
        else:
            app.logger.warning(f"No Statistics entry found for date {date} when deleting row {row_id}")

        # Удаляем запись из таблицы
        db.session.delete(row)
        db.session.commit()

        # Отправляем сообщение в очередь для обновления клиентов
        update_queue.put(json.dumps({"type": "delete", "date": date, "id": row.id}))

        return jsonify({'status': 'success'})
    except Exception as e:
        db.session.rollback()
        app.logger.error(f"Ошибка в delete_row: {str(e)}")
        return jsonify({'status': 'error', 'message': str(e)}), 500


@app.route('/', methods=['GET', 'POST'])
def main():
    if request.method == 'POST':
        worker = request.form.get('worker')
        name = request.form.get('name')

        # Сохраняем информацию о входе
        user = User.query.filter_by(username=name).first()
        if not user:
            user = User(username=name)
            db.session.add(user)

        login_history = LoginHistory(user=user)
        db.session.add(login_history)
        db.session.commit()

        resp = make_response(redirect('/welcome'))
        resp.set_cookie('worker', worker)
        resp.set_cookie('name', name)
        return resp

    return render_template('main.html')


@app.route('/get_current_dl', methods=['GET'])
def get_current_dl():
    date = request.args.get('date')
    if not date:
        return jsonify({"status": "error", "message": "Дата обязательна"}), 400

    dl_counter = DLCounter.query.filter_by(date=date).first()
    if dl_counter:
        return jsonify({"status": "success", "current_dl": dl_counter.counter})
    else:
        return jsonify({"status": "error", "message": "Счетчик DL не инициализирован для этой даты"}), 404


@app.route('/welcome')
def welcome():
    worker = request.cookies.get('worker')
    name = request.cookies.get('name')

    if not worker or not name:
        return redirect('/')

    current_time = datetime.utcnow()
    devices = [device.to_dict(current_time=current_time) for device in Device.query.order_by(Device.name).all()]
    current_time_str = current_time.isoformat()

    return render_template('welcome.html', name=name, worker=worker, table=table, devices=devices, current_time=current_time_str)


@app.route('/logout')
def logout():
    resp = make_response(redirect('/'))
    resp.delete_cookie('worker')
    resp.delete_cookie('name')
    return resp

@app.route('/get_unpacked_rpa_counts', methods=['GET'])
def get_unpacked_rpa_counts():
    year = request.args.get('year')
    month = request.args.get('month')
    
    if not year or not month:
        return jsonify({"status": "error", "message": "Необходимо указать год и месяц"}), 400
    
    try:
        year = int(year)
        month = int(month)
    except ValueError:
        return jsonify({"status": "error", "message": "Год и месяц должны быть числами"}), 400

    # Формируем формат даты для фильтрации
    month_str = f"{month:02d}"
    
    # Запрашиваем количество записей RPA с пустым значением в колонке "Время упаковки" для каждого дня
    unpacked_counts = TableRow.query.filter(
        TableRow.date.like(f"{year}-{month_str}-%"),
        TableRow.arma_type == 'RPA',
        or_(TableRow.pack_time == None, TableRow.pack_time == '')
    ).group_by(TableRow.date).with_entities(TableRow.date, func.count(TableRow.id)).all()
    
    # Преобразуем результат в словарь
    unpacked_counts_dict = {date: count for date, count in unpacked_counts}
    
    return jsonify({'status': 'success', 'unpacked_counts': unpacked_counts_dict})

@app.route('/get_last_dl_number_all_time', methods=['GET'])
def get_last_dl_number_all_time():
    # Получаем последнюю запись с максимальным значением DL за всё время
    last_dl_row = TableRow.query.order_by(TableRow.dl_number.desc()).first()
    if last_dl_row:
        last_dl = last_dl_row.dl_number
        if last_dl and last_dl.startswith('DL'):
            last_dl_number = int(last_dl[2:])
            next_dl_number = last_dl_number + 1
        else:
            next_dl_number = 1
    else:
        next_dl_number = 1

    return jsonify({"status": "success", "next_dl_number": next_dl_number})


@app.route('/import_excel', methods=['POST'])
def import_excel():
    try:
        # Check if a file is provided
        if 'file' not in request.files:
            return jsonify({"status": "error", "message": "No file provided"}), 400

        # Get the uploaded file
        file = request.files['file']

        # Check the file extension for security reasons
        if not file.filename.endswith('.xlsx') and not file.filename.endswith('.xls'):
            return jsonify({"status": "error", "message": "File type not allowed"}), 400

        # Read the Excel file into a DataFrame
        df = pd.read_excel(file)

        # Define the fields expected in the Excel file
        required_columns = ['Время отправки', 'Номер', 'Serial', 'Графа', 'Имя отправителя']

        # Check if all required columns are in the DataFrame
        if not all(col in df.columns for col in required_columns):
            return jsonify({"status": "error", "message": f"Missing required columns. Required columns are: {', '.join(required_columns)}"}), 400

        # Get current date
        current_date = datetime.now().date().strftime("%Y-%m-%d")

        # Iterate over DataFrame rows and insert data into the database
        for _, row in df.iterrows():
            new_row = TableRow(
                date=current_date,
                timestamp=row['Время отправки'],
                number=row['Номер'],
                serial=row['Serial'],
                dl_number=row['Графа'],
                worker_name=row['Имя отправителя'],
                row_number='',  # Will be calculated later
                pack_time='0',  # Default value
                arma_type='0',  # Default value
                dateshipment='0',  # Default value
                aktshipment='0',   # Default value
                bad_recovery=row.get('bad_recovery', False)  # Используем метод get для безопасного доступа
            )
            db.session.add(new_row)
        db.session.commit()

        # Update row numbers
        rows_of_day = TableRow.query.filter_by(date=current_date).order_by(TableRow.id).all()
        for idx, row in enumerate(rows_of_day, 1):
            row.row_number = str(idx)
        db.session.commit()

        return jsonify({"status": "success", "message": "Data imported successfully"})

    except Exception as e:
        db.session.rollback()
        app.logger.error(f"Error during Excel import: {str(e)}")  # Логируем ошибку
        return jsonify({"status": "error", "message": str(e)}), 500
    
@app.route('/delete_imported_data', methods=['POST'])
def delete_imported_data():
    try:
        current_date = datetime.now().date().strftime("%Y-%m-%d")
        rows_deleted = TableRow.query.filter_by(date=current_date).delete()
        db.session.commit()

        return jsonify({"status": "success", "message": f"{rows_deleted} rows deleted for date {current_date}"})

    except Exception as e:
        db.session.rollback()
        return jsonify({"status": "error", "message": str(e)}), 500
    
@app.route('/get_rpa_records', methods=['GET'])
def get_rpa_records():
    try:
        # Замените фильтр по имени 'worker_name' на фильтр по 'arma_type'
        rows = TableRow.query.filter_by(arma_type='RPA').all()

        data = []
        for row in rows:
            data.append({
                'id': row.id,
                'row_number': row.row_number,
                'timestamp': row.timestamp,
                'number': row.number,
                'serial': row.serial,
                'dl_number': row.dl_number,
                'worker_name': row.worker_name,
                'pack_time': row.pack_time,
                'arma_type': row.arma_type,
                'dateshipment': row.dateshipment,
                'aktshipment': row.aktshipment,
                'bad_recovery': row.bad_recovery,
            })

        return jsonify({"status": "success", "data": data})

    except Exception as e:
        return jsonify({"status": "error", "message": str(e)}), 500

@app.route('/export_rpa_excel')
def export_rpa_excel():
    try:
        # Начинаем построение запроса с фильтрации по типу АРМА "RPA"
        query = TableRow.query.filter_by(arma_type='RPA')

        # Дополнительные условия фильтрации: 
        # - dl_number не пустой
        # - pack_time не пустой
        query = query.filter(
            TableRow.dl_number.isnot(None),
            TableRow.dl_number != '',
            TableRow.pack_time.isnot(None),
            TableRow.pack_time != ''
        )

        rows = query.all()

        # Создаем DataFrame только с отфильтрованными данными
        data = []
        for row in rows:
            data.append({
                '№': row.row_number,
                'Время отправки': row.timestamp,
                'Номер': row.number,
                'Serial': row.serial,
                'Графа': row.dl_number,
                'Имя отправителя': row.worker_name,
                'Время упаковки': row.pack_time,
                'Тип АРМА': row.arma_type,
                'Дата отгрузки': row.dateshipment,
                'Номер акта': row.aktshipment,
                'bad_recovery':row.bad_recovery,
            })

        if not data:
            return jsonify({"error": "Нет записей для экспорта с заданными критериями."}), 400

        df = pd.DataFrame(data)

        # Создаем Excel файл
        output = BytesIO()
        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
            df.to_excel(writer, index=False, sheet_name='Sheet1')

            # Настраиваем форматирование
            workbook = writer.book
            worksheet = writer.sheets['Sheet1']

            # Автоматическая ширина столбцов
            for idx, col in enumerate(df.columns):
                series = df[col]
                max_len = max(
                    series.astype(str).map(len).max(),
                    len(str(col))
                ) + 2
                worksheet.set_column(idx, idx, max_len)

                # Форматирование числовых столбцов
                if col in ['Номер', 'Графа']:
                    num_format = workbook.add_format({'num_format': '0'})
                    worksheet.set_column(idx, idx, max_len, num_format)

        output.seek(0)

        return send_file(
            output,
            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            as_attachment=True,
            download_name='RPA_export.xlsx'
        )

    except Exception as e:
        print(f"Export error: {str(e)}")
        return jsonify({"error": str(e)}), 500
    

@app.route('/get_duplicates', methods=['GET'])
def get_duplicates():
    try:
        # Получаем значение фильтра для типа АРМА
        filter_arma = request.args.get('filter_arma')

        # Получаем все строки из таблицы с учетом фильтра
        if filter_arma:
            rows = TableRow.query.filter_by(arma_type=filter_arma).all()
        else:
            rows = TableRow.query.all()

        # Хранилища для множества значений
        numbers = {}
        serials = {}
        dl_numbers = {}

        # Собираем все значения и их индексы
        data = []
        for row in rows:
            row_data = {
                'id': row.id,
                'row_number': row.row_number,
                'timestamp': row.timestamp,
                'number': row.number,
                'serial': row.serial,
                'dl_number': row.dl_number,
                'worker_name': row.worker_name,
                'pack_time': row.pack_time,
                'arma_type': row.arma_type,
                'dateshipment': row.dateshipment,
                'aktshipment': row.aktshipment,
                'bad_recovery': row.bad_recovery,
            }
            data.append(row_data)

            # Если тип АРМА "SRC", собираем только по serial
            if filter_arma == 'SRC':
                if row.serial:
                    clean_serial = ''.join(filter(str.isdigit, row.serial))
                    if clean_serial in serials:
                        serials[clean_serial].append(len(data) - 1)
                    else:
                        serials[clean_serial] = [len(data) - 1]
            else:
                # Для других типов собираем по всем полям
                if row.number:
                    clean_number = ''.join(filter(str.isdigit, row.number))
                    if clean_number in numbers:
                        numbers[clean_number].append(len(data) - 1)
                    else:
                        numbers[clean_number] = [len(data) - 1]

                if row.dl_number:
                    clean_dl_number = ''.join(filter(str.isdigit, row.dl_number))
                    if clean_dl_number in dl_numbers:
                        dl_numbers[clean_dl_number].append(len(data) - 1)
                    else:
                        dl_numbers[clean_dl_number] = [len(data) - 1]

        # Фильтруем только реальные дубликаты
        duplicate_numbers = {k: v for k, v in numbers.items() if len(v) > 1}
        duplicate_serials = {k: v for k, v in serials.items() if len(v) > 1}
        duplicate_dl_numbers = {k: v for k, v in dl_numbers.items() if len(v) > 1}

        duplicates = {
            "numbers": duplicate_numbers,
            "serials": duplicate_serials,
            "dl_numbers": duplicate_dl_numbers
        }

        duplicate_indices = set()
        for indices in duplicate_numbers.values():
            duplicate_indices.update(indices)
        for indices in duplicate_serials.values():
            duplicate_indices.update(indices)
        for indices in duplicate_dl_numbers.values():
            duplicate_indices.update(indices)

        duplicates_data = [data[idx] for idx in duplicate_indices]

        return jsonify({
            "status": "success",
            "data": duplicates_data,
            "duplicates": duplicates
        })

    except Exception as e:
        return jsonify({"status": "error", "message": str(e)})

    
def ping_device(ip_address):
    try:
        # Determine the OS and use appropriate ping command
        param = '-n' if platform.system().lower() == 'windows' else '-c'
        command = ['ping', param, '1', ip_address]
        result = subprocess.run(command, capture_output=True, text=True)

        # Check if the word "unreachable" is in the output, which indicates failure
        if "unreachable" in result.stdout:
            return False
        elif result.returncode == 0:
            return True
        else:
            return False
    except Exception as e:
        print(f"An error occurred while pinging {ip_address}: {e}")
        return False


@app.route('/ping_arm1')
def ping_arm1():
    ip_address = "192.168.50.108"
    is_online = ping_device(ip_address)
    status = 'online' if is_online else 'offline'
    app.logger.debug(f"Ping status for {ip_address}: {status}")
    return jsonify({"status": status})

@app.route('/send_file', methods=['POST'])
def send_file():
    try:
        # Path of the file to be sent
        local_file_path = "C:\\bat\\BAT\\apk640\\activationGlaz.py"
        filename = 'activationGlaz.py'

        # Ensure the file exists locally
        if not os.path.isfile(local_file_path):
            return jsonify({"status": "error", "message": "File not found"}), 404

        # Setup SSH connection
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect('192.168.50.108', username='moon', password='noom')

        # Send file to Raspberry Pi
        sftp = ssh.open_sftp()
        remote_path = f'/home/moon/Desktop/{filename}'
        sftp.put(local_file_path, remote_path)
        sftp.close()

        # Execute the file on Raspberry Pi
        stdin, stdout, stderr = ssh.exec_command(f'python3 {remote_path}')  # Use 'python3' for Python 3
        stdout_result = stdout.read().decode('utf-8')
        stderr_result = stderr.read().decode('utf-8')

        ssh.close()

        if stderr_result:
            return jsonify({"status": "error", "message": stderr_result}), 500

        return jsonify({"status": "success", "message": 'Файл отправлен и запущен на Raspberry Pi', "stdout": stdout_result})

    except Exception as e:
        return jsonify({"status": "error", "message": str(e)}), 500

if __name__ == '__main__':
    with app.app_context():
        db.create_all()
        create_devices()


    logging.disable(logging.CRITICAL)
    os.system('title СЕРВЕР')
    app.run(host='192.168.50.110', port=80, debug=True)  #192.168.50.99


let isEditing = false;
let isRPAFilterActive = false;
let isShowingDuplicates = false;
let searchTimeout;
let lastUpdateTime = 0;
const updateInterval = 1000;
let eventSource;
let lastData = null;
let isDeleting = false;
let fpInstance;
let unpackedDaysCache = {}; // Ключи будут в формате 'YYYY-MM', значение - Set дней
const deviceSparklines = {};

// Глобальные переменные для отслеживания сортировки
let globalSortColumn = null;
let globalSortOrder = 'asc';

function getSelectedDate() {
    return $('#datepicker').val();
}

// Функция для получения состояния фильтра
function getArmaFilter() {
    return $('#armaFilter').is(':checked') ? 'RPA' : '';
}

function updateTable(force = false, highlightNew = false) {
    return new Promise((resolve, reject) => {
        const now = Date.now();
        if (!force && now - lastUpdateTime < updateInterval) {
            resolve();
            return;
        }
        if (isEditing) {
            resolve();
            return;
        }

        if (isEditing || isDeleting) { // Добавляем проверку на isDeleting
            resolve();
            return;
        }

        // Проверьте, если фильтр RPA активен, не выполняйте обновление автоматически
        if (isRPAFilterActive) {
            resolve();
            return;
        }
       
        if (isShowingDuplicates) {
            resolve();
            return;
        }

        $.ajax({
            url: '/get_table_data',
            type: 'GET',
            data: { 
                date: getSelectedDate(),
                filter_arma: getArmaFilter()
            },
            success: function(response) {
                var tableBody = $('#tableBody');

                // Обновляем содержимое таблицы
                updateTableContent(response.data, tableBody, highlightNew);

                // Применяем текущую сортировку
                if (globalSortColumn !== null) {
                    sortTable(globalSortColumn, globalSortOrder);
                }

                updateStatistics();
                checkDuplicates(); 
                lastUpdateTime = now;

                // Проверяем и подсвечиваем дубликаты
                highlightDuplicates(response.duplicates);

                resolve();
            },
            error: function(xhr, status, error) {
                console.error('Error updating table:', error);
                reject(error);
            }
        });
    });
}

function initializeSparklines(activity) {
    for (const [name, data] of Object.entries(activity)) {
        const sparklineSpan = $(`#${name}-sparkline`);
        sparklineSpan.sparkline(data, {
            type: 'line',
            width: '300px',  // Увеличенная ширина
            height: '50px',  // Также можно увеличить высоту для лучшей видимости
            lineColor: 'green',
            fillColor: 'transparent',
            spotColor: 'red',          // Отображение пиков
            minSpotColor: 'blue',      // Минимальные пики
            maxSpotColor: 'orange',    // Максимальные пики
            highlightSpotColor: 'blue',
            highlightLineColor: 'blue'
        });
        sparklineSpan.data('sparkline-initialized', true);
    }
}

function updateSparklines(devices, activity) {
    for (const [name, status] of Object.entries(devices)) {
        const sparklineSpan = $(`#${name}-sparkline`);
        const data = activity[name];

        // Determine line color based on device status
        let lineColor = 'green';  // Default color

        if (status === 'processing') {
            lineColor = 'green';  // Color for processing state
        } else if (status === 'copying') {
            lineColor = 'orange';
        } else if (status === 'sending_number') {
            lineColor = 'blue';
        } else if (status === 'no_internet') {
            lineColor = 'red';
        }

        // Check for impulse (e.g., value > 4)
        const lastValue = data[data.length - 1];
        if (lastValue > 4) {
            lineColor = 'purple';  // Color for impulse
        }

        if (sparklineSpan.data('sparkline-initialized')) {
            // Update existing Sparkline
            sparklineSpan.sparkline(data, {
                type: 'line',
                width: '100%', 
                height: '20px', 
                lineColor: lineColor,
                fillColor: 'transparent',
                spotColor: 'red',
                minSpotColor: 'blue',
                maxSpotColor: 'orange',
                highlightSpotColor: 'blue',
                highlightLineColor: 'blue'
            });
        } else {
            // Initialize Sparkline if not already
            sparklineSpan.sparkline(data, {
                type: 'line',
                width: '100%', 
                height: '50px', 
                lineColor: lineColor,
                fillColor: 'transparent',
                spotColor: 'red',
                minSpotColor: 'blue',
                maxSpotColor: 'orange',
                highlightSpotColor: 'blue',
                highlightLineColor: 'blue'
            });
            sparklineSpan.data('sparkline-initialized', true);
        }
    }
}

function fetchDeviceStatuses() {
    $.ajax({
        url: '/get_device_status',
        type: 'GET',
        success: function(response) {
            if (response.status === 'success') {
                const devices = response.devices;
                const activity = response.activity;

                for (const [name, deviceInfo] of Object.entries(devices)) {
                    const status = deviceInfo.status;

                    // Обновление статуса устройства
                    const statusCircle = $(`#${name}-status`);
                    const statusText = $(`#${name}-status-text`);
                    statusCircle.removeClass('online offline no_internet copying sending_number processing');

                    if (status === 'offline') {
                        statusCircle.addClass('offline');
                        statusText.text('Нет соединения');
                    } else if (status === 'no_internet') {
                        statusCircle.addClass('no_internet');
                        statusText.text('Нет интернета');
                    } else if (status === 'copying') {
                        statusCircle.addClass('copying');
                        statusText.text('Копирование');
                    } else if (status === 'sending_number') {
                        statusCircle.addClass('sending_number');
                        statusText.text('Отправка номера');
                    } else if (status === 'online') {
                        statusCircle.addClass('online');
                        statusText.text('Онлайн');
                    } else if (status === 'processing') {
                        // Если все еще есть устройства, для которых нужен статус 'processing'
                        statusCircle.addClass('processing');
                        statusText.text('Онлайн');
                    }
                }

                // Обновление спарклайнов активности
                updateSparklines(devices, activity);
            }
        },
        error: function(error) {
            console.error('Ошибка при получении статусов устройств:', error);
        }
    });
}


function highlightDuplicates(duplicates) {
    // Очищаем предыдущие выделения
    $('#tableBody td').removeClass('duplicate-highlight');

    if (!duplicates) {
        console.warn("Объект duplicates не определен");
        return;
    }

    // Подсвечиваем дубликаты номеров
    if (duplicates.numbers) {
        for (let number in duplicates.numbers) {
            duplicates.numbers[number].forEach(index => {
                $(`#tableBody tr:eq(${index}) td:nth-child(3)`).addClass('duplicate-highlight');
            });
        }
    }

    // Подсвечиваем дубликаты серийных номеров
    if (duplicates.serials) {
        for (let serial in duplicates.serials) {
            duplicates.serials[serial].forEach(index => {
                $(`#tableBody tr:eq(${index}) td:nth-child(4)`).addClass('duplicate-highlight');
            });
        }
    }

    // Подсвечиваем дубликаты "Графа" (dl_number)
    if (duplicates.dl_numbers) {
        for (let dl_number in duplicates.dl_numbers) {
            duplicates.dl_numbers[dl_number].forEach(index => {
                $(`#tableBody tr:eq(${index}) td:nth-child(5)`).addClass('duplicate-highlight');
            });
        }
    }
}


function updateCell(cell, newValue, rowId, cellIndex, rowData) {
    console.log(`Updating cell: index=${cellIndex}, value=${newValue}, rowId=${rowId}`);

    const excludedArmaTypes = ["CFA", "VND", "SRC"];

    if (cellIndex === 4) { // Столбец "Графа"
        if (rowData.arma_type === 'RPA' && !excludedArmaTypes.includes(rowData.arma_type)) {
            if (newValue && newValue.startsWith('DL')) {
                cell.text(newValue)
                    .addClass('clickable')
                    .css('cursor', 'pointer')
                    .off('click') // Удаляем предыдущие обработчики
                    .on('click', function() {
                        copyToClipboard(newValue);
                        $(this).addClass('copied');
                        setTimeout(() => {
                            $(this).removeClass('copied');
                        }, 200);
                    });

                // Обновляем data-value
                let numericValue = parseDL(newValue) || 0;
                cell.attr('data-value', numericValue);
            } else {
                cell.html('<button class="generate-button">Генерировать</button>')
                    .find('button')
                    .click(function() {
                        generateDL(rowId);
                    });

                // Обновляем data-value
                cell.attr('data-value', 0);
            }
        } else if (!excludedArmaTypes.includes(rowData.arma_type)) {
            if (newValue && newValue.startsWith('DL')) {
                cell.text(newValue)
                    .addClass('clickable')
                    .css('cursor', 'pointer')
                    .off('click')
                    .on('click', function() {
                        copyToClipboard(newValue);
                        $(this).addClass('copied');
                        setTimeout(() => {
                            $(this).removeClass('copied');
                        }, 200);
                    });

                // Обновляем data-value
                let numericValue = parseDL(newValue) || 0;
                cell.attr('data-value', numericValue);
            } else {
                cell.text(newValue || '');
                // Обновляем data-value
                let numericValue = parseDL(newValue) || 0;
                cell.attr('data-value', numericValue);
            }
        } else {
            cell.text(newValue || '');
            // Обновляем data-value
            let numericValue = parseDL(newValue) || 0;
            cell.attr('data-value', numericValue);
        }
    } else if (cellIndex === 6) { // Столбец "Время упаковки"
        const dlCell = cell.parent().find('td').eq(4);
        const dlValue = dlCell.text().trim();
        const armaType = rowData.arma_type;

        if (dlValue.startsWith('DL') && !newValue && !excludedArmaTypes.includes(armaType)) {
            cell.html('<button class="pack-button">Упаковать</button>')
                .find('button')
                .click(function() {
                    packItem(rowId);
                });
        } else {
            cell.text(newValue);
        }
    } else if (cellIndex === 7) { // Столбец "Тип АРМА"
        if (!newValue || newValue.trim() === '') {
            newValue = 'RPA';
        }
        cell.text(newValue)
            .toggleClass('editable', true)
            .attr('data-column', cellIndex);
    } else {
        cell.text(newValue)
            .toggleClass('editable', cellIndex === 2 || cellIndex === 3)
            .attr('data-column', cellIndex);
    }
}

function sortTable(column, order) {
    const rows = $('#tableBody > tr').get();

    rows.sort(function(a, b) {
        let A = $(a).children('td').eq(column).text().trim();
        let B = $(b).children('td').eq(column).text().trim();

        // Обработка пустых значений
        if (A === '' && B === '') return 0;
        if (A === '') return order === 'asc' ? 1 : -1;
        if (B === '') return order === 'asc' ? -1 : 1;

        // Специальная обработка для столбца "Графа" (dl_number) с использованием data-value
        if (column === 4) { // Индекс столбца "Графа"
            let numA = parseInt($(a).children('td').eq(column).attr('data-value')) || 0;
            let numB = parseInt($(b).children('td').eq(column).attr('data-value')) || 0;

            // Отладочные сообщения
            console.log(`Сортировка Графа: numA = ${numA}; numB = ${numB}`);

            return order === 'asc' ? numA - numB : numB - numA;
        }

        // Обработка дат и времени для соответствующих столбцов
        if (column === 1 || column === 6) {  // Столбцы "Время отправки" и "Время упаковки"
            let dateA = Date.parse(A);
            let dateB = Date.parse(B);
            if (isNaN(dateA)) dateA = 0;
            if (isNaN(dateB)) dateB = 0;
            return order === 'asc' ? dateA - dateB : dateB - dateA;
        }

        // Обработка числовых столбцов
        if (column === 0 || column === 2) {  // Столбцы с числами (№ и Номер)
            let numA = parseFloat(A) || 0;
            let numB = parseFloat(B) || 0;
            return order === 'asc' ? numA - numB : numB - numA;
        }

        // Обработка строковых столбцов
        if (column === 5) {  // Столбец с именем отправителя
            A = A.toLowerCase();
            B = B.toLowerCase();
        }

        // Строковое сравнение для остальных столбцов
        A = A.toUpperCase();
        B = B.toUpperCase();
        if (A < B) return order === 'asc' ? -1 : 1;
        if (A > B) return order === 'asc' ? 1 : -1;
        return 0;
    });

    // Очистка тела таблицы
    $('#tableBody').empty();

    // Добавление отсортированных строк
    $.each(rows, function(index, row) {
        $('#tableBody').append(row);
    });

    checkDuplicates();
    bindEventHandlers();
}

function parseDL(dl_number) {
    if (typeof dl_number !== 'string') return null;
    dl_number = dl_number.trim();
    let match = dl_number.match(/^DL[-\s]?(\d+)$/i);
    if (match && match[1]) {
        return parseInt(match[1], 10);
    }
    return null;
}

function generateDL(rowId) {
    console.log(`Generating DL for row ID ${rowId}`);
    const selectedDate = getSelectedDate();
    console.log("Selected date:", selectedDate);

    $.ajax({
        url: '/generate_dl',
        type: 'POST',
        contentType: 'application/json',
        data: JSON.stringify({
            id: rowId,
            date: selectedDate
        }),
        success: function(response) {
            if (response.status === 'success') {
                console.log('DL успешно сгенерирован:', response.dl_number);
                var row = $(`#tableBody tr[data-id='${rowId}']`);
                var dlCell = row.find('td:eq(4)');
                var packCell = row.find('td:eq(6)'); // Столбец "Время упаковки"
                var armaType = row.find('td:eq(7)').text().trim();

                dlCell.text(response.dl_number)
                    .addClass('clickable')
                    .css('cursor', 'pointer')
                    .off('click') // Удаляем предыдущие обработчики
                    .on('click', function() {
                        copyToClipboard(response.dl_number);
                        $(this).addClass('copied');
                        setTimeout(() => {
                            $(this).removeClass('copied');
                        }, 200);
                    });

                // Добавляем кнопку упаковки только если arma_type не исключен
                const excludedArmaTypes = ["CFA", "VND", "SRC"];
                if (!excludedArmaTypes.includes(armaType)) {
                    packCell.html('<button class="pack-button">Упаковать</button>')
                        .find('button')
                        .click(function() {
                            packItem(rowId);
                        });
                }

                // Обновляем поле initial-dl с текущим значением DL
                loadCurrentDL();
            } else {
                alert('Ошибка при генерации DL: ' + response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('Ошибка при генерации DL:', status, error);
            alert('Ошибка при генерации DL: ' + error);
        }
    });
}

function packItem(rowId) {
    console.log(`Упаковка элемента для строки ID ${rowId}`);
    const selectedDate = getSelectedDate();
    console.log("Selected date:", selectedDate);

    $.ajax({
        url: '/pack_item',
        type: 'POST',
        contentType: 'application/json',
        data: JSON.stringify({
            id: rowId,
            date: selectedDate
        }),
        success: function(response) {
            console.log("Ответ сервера:", response);
            if (response.status === 'success') {
                var row = $(`#tableBody tr[data-id='${rowId}']`);
                row.addClass('packed-row');
                var cell = row.find('td:eq(6)'); // Столбец "Время упаковки"
                cell.text(response.pack_time);
                updateStatistics();

                // Удаляем кнопку "Упаковать", так как запись уже упакована
                cell.find('button.pack-button').remove();

                // Определяем год и месяц из `selectedDate`
                const [year, month, day] = selectedDate.split('-').map(Number);

                // Принудительно обновляем неупакованные дни для этого месяца
                markUnpackedDays(year, month, true);
            } else {
                alert('Ошибка при упаковке: ' + response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error("Ошибка AJAX:", xhr, status, error);
            alert('Ошибка при упаковке: ' + error);
        }
    });
}

function areSimilarNumbers(num1, num2) {
    // Очищаем строки от нецифровых символов и пробелов
    const clean1 = num1.toString().replace(/\D/g, '').trim();
    const clean2 = num2.toString().replace(/\D/g, '').trim();
    
    // Если строки пустые или разной длины - не дубликаты
    if (!clean1 || !clean2 || clean1.length !== clean2.length) {
        return false;
    }
    
    // Проверяем на точное совпадение
    return clean1 === clean2;
}

function checkDuplicates() {
    
    const rows = $('#tableBody tr');
    
    // Очищаем предыдущие выделения
    rows.find('td').removeClass('duplicate-highlight');
    
    // Создаем массивы для хранения номеров и их индексов
    const numbers = new Map();
    const dl_numbers = new Map();
    const serials = new Map();
    
    // Собираем все номера и серийные номера
    rows.each(function(index) {
        const number = $(this).find('td:nth-child(3)').text().trim();
        const serial = $(this).find('td:nth-child(4)').text().trim();
        const dl_number = $(this).find('td:nth-child(5)').text().trim();
        
        if (number) {
            if (!numbers.has(number)) {
                numbers.set(number, []);
            }
            numbers.get(number).push(index);
        }

        if (dl_number) {
            if (!dl_numbers.has(dl_number)) {
                dl_numbers.set(dl_number, []);
            }
            dl_numbers.get(dl_number).push(index);
        }
        
        if (serial) {
            if (!serials.has(serial)) {
                serials.set(serial, []);
            }
            serials.get(serial).push(index);
        }
    });
    
    // Подсвечиваем дубликаты
    let duplicatesFound = false;
    


    dl_numbers.forEach((indices, dl_number) => {
        if (dl_number.startsWith("DL")) {
            if (indices.length > 1) {
                indices.forEach(index => {
                    rows.eq(index).find('td:nth-child(5)').addClass('duplicate-highlight');
                });
                duplicatesFound = true;
            }
        }
    });

    // Проверяем номера
    numbers.forEach((indices, number) => {
        if (indices.length > 1) {
            indices.forEach(index => {
                rows.eq(index).find('td:nth-child(3)').addClass('duplicate-highlight');
            });
            duplicatesFound = true;
        }
    });

    // // Проверяем грайвера
    // dl_numbers.forEach((indices, dl_number) => {
    //     if (indices.length > 1) {
    //         indices.forEach(index => {
    //             rows.eq(index).find('td:nth-child(5)').addClass('duplicate-highlight');
    //         });
    //         duplicatesFound = true;
    //     }
    // });
    
    // Проверяем серийные номера
    serials.forEach((indices, serial) => {
        if (indices.length > 1) {
            indices.forEach(index => {
                rows.eq(index).find('td:nth-child(4)').addClass('duplicate-highlight');
            });
            duplicatesFound = true;
        }
    });

    return duplicatesFound;
}

function appendNewRow(tableBody, rowData) {
    console.log("Добавление новой строки:", rowData);

    // Создаем элемент строки и присваиваем уникальный data-id
    var tr = $('<tr>').attr('data-id', rowData.id);

    // Если есть время упаковки и это не заголовок, добавляем класс 'packed-row'
    if (rowData.pack_time && rowData.pack_time !== "Время упаковки") {
        tr.addClass('packed-row');
    }

    // Добавляем ячейки в строку
    tr.append($('<td>').text(rowData.row_number));
    tr.append($('<td>').text(rowData.timestamp));

    // Столбец "Номер" (Третий столбец, индекс 2)
    var numberCell = $('<td>')
        .text(rowData.number)
        .addClass('editable') // Добавляем класс для редактирования
        .attr('data-column', '2'); // Указываем индекс столбца
    tr.append(numberCell);

    tr.append($('<td>').text(rowData.serial));

    // Столбец "Графа" (Пятый столбец, индекс 4)
    var dlCell = $('<td>')
        .text(rowData.dl_number || '')
        .addClass('editable') // Добавляем класс для редактирования
        .attr('data-column', '4'); // Указываем индекс столбца "Графа"
    tr.append(dlCell);
    
    // Добавляем data-value
    var numericValue = parseDL(rowData.dl_number) || 0;
    dlCell.attr('data-value', numericValue);

    // Проверка и добавление кнопок или кликабельного текста для "Графа"
    const excludedArmaTypes = ["CFA", "VND", "SRC"];

    if (rowData.arma_type === 'RPA' && !excludedArmaTypes.includes(rowData.arma_type)) {
        // Для типа АРМА 'RPA', проверяем наличие и формат dl_number
        if (!rowData.dl_number || !rowData.dl_number.startsWith('DL')) {
            // Если dl_number отсутствует или не начинается с 'DL', отображаем кнопку "Генерировать"
            dlCell.html('<button class="generate-button">Генерировать</button>')
                .find('button')
                .click(function() {
                    generateDL(rowData.id); // Передаем уникальный ID строки
                });
        } else {
            // Если dl_number присутствует и начинается с 'DL', делаем его кликабельным для копирования
            dlCell.text(rowData.dl_number)
                .addClass('clickable')
                .css('cursor', 'pointer')
                .on('click', function() {
                    copyToClipboard(rowData.dl_number);
                    $(this).addClass('copied');
                    setTimeout(() => {
                        $(this).removeClass('copied');
                    }, 200);
                });
        }
    } else if (!excludedArmaTypes.includes(rowData.arma_type)) {
        // Для других типов АРМА, которые не исключены, отображаем или скрываем кнопку
        if (rowData.dl_number && rowData.dl_number.startsWith('DL')) {
            dlCell.text(rowData.dl_number)
                .addClass('clickable')
                .css('cursor', 'pointer')
                .on('click', function() {
                    copyToClipboard(rowData.dl_number);
                    $(this).addClass('copied');
                    setTimeout(() => {
                        $(this).removeClass('copied');
                    }, 200);
                });
        } else {
            dlCell.text(rowData.dl_number || '');
        }
    } else {
        // Для типов АРМА "CFA", "VND", "SRC" оставляем ячейку пустой или с текущим значением
        dlCell.text(rowData.dl_number || '');
    }

    // Добавляем ячейку с именем отправителя
    tr.append($('<td>').text(rowData.worker_name));

    /**
     * Обработка ячейки "Время упаковки" (pack_time)
     */
    var packCell = $('<td>');

    if (rowData.dl_number && rowData.dl_number.startsWith('DL') && !rowData.pack_time && !excludedArmaTypes.includes(rowData.arma_type)) {
        // Если dl_number с 'DL', pack_time отсутствует и arma_type не исключен, показываем кнопку "Упаковать"
        packCell.html('<button class="pack-button">Упаковать</button>')
            .find('button')
            .click(function() {
                packItem(rowData.id); // Передаем уникальный ID строки
            });
    } else {
        // Иначе отображаем время упаковки или оставляем пустым
        packCell.text(rowData.pack_time || '');
    }

    tr.append(packCell);

    // Добавляем ячейку с типом АРМА
    tr.append($('<td>').text(rowData.arma_type || ''));

    tr.append($('<td>').text(rowData.dateshipment));  
    tr.append($('<td>').text(rowData.aktshipment));
    tr.append($('<td>').text(rowData.bad_recovery)); 

   
    /**
     * Добавление ячейки "Действие" с кнопкой "Удалить"
     */
    var actionTd = $('<td>')
    var deleteButton = $('<button>').text('Удалить').addClass('delete-button btn btn-danger btn-sm')
    deleteButton.click(function() {
        initiateDeleteConfirmation(rowData.id); // Используем новую функцию
    });
    actionTd.append(deleteButton);
    tr.append(actionTd);

    // Добавляем строку в тело таблицы
    tableBody.append(tr);

    /**
     * Дополнительная обработка после добавления строки
     */
    setTimeout(() => {
        const dlValue = dlCell.text().trim();
        const packValue = packCell.text().trim();

        if (dlValue.startsWith('DL') && !packValue && !excludedArmaTypes.includes(rowData.arma_type)) {
            console.log('Добавляем кнопку упаковки для DL:', dlValue);
            packCell.html('<button class="pack-button">Упаковать</button>')
                .find('button')
                .click(function() {
                    packItem(rowData.id); // Передаем уникальный ID строки
                });
        }

        // Проверяем дубликаты после добавления новой строки
        checkDuplicates();
    }, 100);
}


function bindEventHandlers() {
    // Привязка обработчика для кнопки "Генерировать"
    $('.generate-button').off('click').on('click', function() {
        var rowId = $(this).closest('tr').data('id');
        generateDL(rowId);
    });

    // Привязка обработчика для кнопки "Упаковать"
    $('.pack-button').off('click').on('click', function() {
        var rowId = $(this).closest('tr').data('id');
        packItem(rowId);
    });

    // Привязка обработчика для кнопки "Удалить"
    $('.delete-button').off('click').on('click', function() {
        var rowId = $(this).closest('tr').data('id');
        initiateDeleteConfirmation(rowId);
    });
}

function updateTableContent(data, tableBody, highlightNew = false) {
    tableBody.empty();  // Очищаем текущее содержимое таблицы
    data.forEach(function(rowData) {
        appendNewRow(tableBody, rowData);
    });
    
    bindEventHandlers();  // Привязываем обработчики после обновления таблицы
}

function scheduleNextUpdate() {
    setTimeout(() => {
        if (!isEditing) {
            updateTable(false, false).then(() => {
                scheduleNextUpdate();
            });
        } else {
            scheduleNextUpdate();
        }
    }, 3000);
}

function initializeEventSource() {
    if (eventSource) {
        eventSource.close();
    }

    eventSource = new EventSource('/stream');

    eventSource.onmessage = function(event) {
        const data = JSON.parse(event.data);
        if (data.type === 'update' && data.date === getSelectedDate()) {
            // Обновляем таблицу
            updateTable(true).then(() => {
                // После обновления таблицы, обновляем подсветку дней
                const currentDate = new Date(fpInstance.selectedDates[0]);
                markUnpackedDays(currentDate.getFullYear(), currentDate.getMonth() + 1);
                fetchDeviceStatuses();
            });
        }
    };

    eventSource.onerror = function(error) {
        console.error('EventSource failed:', error);
        eventSource.close();
        setTimeout(initializeEventSource, 5000);  // Попытка переподключения через 5 секунд
    };
}

// Обработчики событий для таблицы
$(document).ready(function() {
    updateTable();
    updateStatistics(); // Убедитесь, что эта функция определена
    initializeEventSource();
    scheduleNextUpdate();
    fetchDeviceStatuses();
    loadCurrentDL();
    // Обработчик сортировки
    $('.sortable').click(function() {
        const column = $(this).data('column');
        const order = $(this).hasClass('asc') ? 'desc' : 'asc';
        
        // Удаляем классы сортировки со всех заголовков
        $('.sortable').removeClass('asc desc');
        // Добавляем класс текущей сортировки
        $(this).addClass(order);
        
        // Сохраняем текущие параметры сортировки
        globalSortColumn = column;
        globalSortOrder = order;
        
        // Сортируем таблицу
        sortTable(column, order);
    });

    // Обработчик поиска
    $('#searchButton').click(function() {
        searchNumber();
    });
    $('#searchInput').keypress(function(e) {
        if (e.which === 13) {
            searchNumber();
        }
    });
    $('#armaFilter').on('change', function() {
        updateTable();
    });
});

// Обработчик изменения даты
$('#datepicker').on('change', function() {
    initializeEventSource();
    updateTable();
});

// Обработчик экспорта в Excel
$(document).ready(function() {
    $('.export-button').on('click', function(e) {
        e.preventDefault();
        
        // Получаем информацию о сортировке
        const sortableColumn = $('.sortable.asc, .sortable.desc');
        const sortColumn = sortableColumn.length ? sortableColumn.data('column') : '';
        const sortOrder = $('.sortable.asc').length ? 'asc' : 'desc';
        
        const url = '/export_rpa_excel';


        // Формируем URL
        const date = getSelectedDate();
        const queryParams = new URLSearchParams({
            date: date,
            sort_column: sortColumn || '',
            sort_order: sortOrder
        });
        
        fetch(url)
        .then(response => {
            if (response.ok) {
                return response.blob();
            }
            throw new Error('Network response was not ok.');
        })
        .then(blob => {
            // Создаем ссылку для скачивания
            const url = window.URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = 'RPA_export.xlsx';
            document.body.appendChild(a);
            a.click();
            window.URL.revokeObjectURL(url);
            a.remove();
        })
        .catch(error => {
            console.error('Error:', error);
            alert('Ошибка при экспорте файла');
        });})
});

$(document).ready(function() {
    fpInstance = flatpickr("#datepicker", {
        locale: "ru",
        dateFormat: "Y-m-d",
        defaultDate: "today",
        onChange: function(selectedDates, dateStr, instance) {
            updateTable();
            const selected = selectedDates[0];
            if (selected) {
                markUnpackedDays(selected.getFullYear(), selected.getMonth() + 1);
            }
        },
        onMonthChange: function(selectedDates, dateStr, instance) {
            const selected = instance.currentYear && instance.currentMonth !== undefined
                ? new Date(instance.currentYear, instance.currentMonth, 1)
                : new Date();
            markUnpackedDays(selected.getFullYear(), selected.getMonth() + 1);
        },
        onDayCreate: function(dObj, dStr, fp, dayElem) {
            const year = dayElem.dateObj.getFullYear();
            const month = dayElem.dateObj.getMonth() + 1; // getMonth() возвращает 0-11
            const day = dayElem.dateObj.getDate();
            const key = `${year}-${String(month).padStart(2, '0')}`;
            
            if (unpackedDaysCache[key] && unpackedDaysCache[key].has(day)) {
                dayElem.style.backgroundColor = 'lightcoral';
                dayElem.style.color = 'white';
            } else {
                // Сброс стилей для других дней
                dayElem.style.backgroundColor = '';
                dayElem.style.color = '';
            }
        }
    });

    // Инициализируем для текущего месяца
    const today = new Date();
    markUnpackedDays(today.getFullYear(), today.getMonth() + 1);

    initializeEventSource();
    updateTable();
    updateStatistics();
    fetchDeviceStatuses();
    setInterval(fetchDeviceStatuses, 1000); // Интервал 1 секунду (скорректируйте при необходимости)
});


// Обработчик двойного клика для редактирования ячеек
$(document).on('dblclick', '.editable', function() {
    if (isEditing) return; // Предотвращаем многократное редактирование
    isEditing = true;

    var td = $(this);
    var currentValue = td.text();
    var input = $('<input type="text">')
        .val(currentValue)
        .addClass('edit-input');

    td.html(input);
    input.focus();

    input.on('blur', function() {
        var newValue = $(this).val().trim();
        var rowId = td.closest('tr').data('id');
        var columnIndex = td.attr('data-column');

        // Определяем URL для обновления в зависимости от столбца
        let url;
        let updateData = {
            id: rowId,
            new_value: newValue,
            date: getSelectedDate()
        };

        if (columnIndex === '2') { // Столбец "Номер"
            url = '/update_number';
        } else if (columnIndex === '4') { // Столбец "Графа"
            url = '/update_graf';
        } else {
            alert('Неподдерживаемый столбец для редактирования');
            td.text(currentValue);
            isEditing = false;
            return;
        }

        $.ajax({
            url: url,
            type: 'POST',
            contentType: 'application/json',
            data: JSON.stringify(updateData),
            success: function(response) {
                if (response.status === 'success') {
                    td.text(newValue);
                    checkDuplicates();
                } else {
                    alert('Ошибка при обновлении значения: ' + response.message);
                    td.text(currentValue);
                }
                isEditing = false;
            },
            error: function(xhr, status, error) {
                alert('Ошибка при отправке данных: ' + error);
                td.text(currentValue);
                isEditing = false;
            }
        });
    });

    input.on('keypress', function(e) {
        if (e.which === 13) { // Нажатие Enter
            $(this).blur();
        }
    });

    input.on('keydown', function(e) {
        if (e.key === 'Escape') { // Нажатие Esc
            td.text(currentValue);
            isEditing = false;
        }
    });
});

function searchNumber() {
    const searchValue = $('#searchInput').val().trim();
    if (!searchValue) return;

    // Удаляем предыдущую подсветку
    $('.highlight-search').removeClass('highlight-search');

    const rows = $('#tableBody tr');
    let found = false;

    rows.each(function() {
        const numberCell = $(this).find('td:nth-child(3)');
        const cellText = numberCell.text().trim();
        if (cellText === searchValue) {
            numberCell.addClass('highlight-search');
            
            // Прокрутка к найденной строке
            $('.table-container').animate({
                scrollTop: $(this).offset().top - $('.table-container').offset().top + $('.table-container').scrollTop() - 100
            }, 500);

            found = true;

            // Устанавливаем таймер на удаление подсветки через 3 секунды
            setTimeout(() => {
                numberCell.removeClass('highlight-search');
            }, 3000);

            // Выводим сообщение в консоль для отладки
            console.log('Найдено совпадение:', cellText);

            return false; // Прерываем цикл, так как нашли нужную строку
        }
    });

    if (!found) {
        alert('Точное совпадение номера не найдено');
    }
}

function initiateDeleteConfirmation(rowId) {
    isDeleting = true; // Устанавливаем флаг подтверждения удаления
    var deleteCell = $(`tr[data-id='${rowId}'] td:last-child`);

    // Проверяем, не находится ли уже в состоянии подтверждения
    if (deleteCell.data('confirming')) {
        return; // Если подтверждение уже запрошено, ничего не делаем
    }

    // Устанавливаем флаг подтверждения
    deleteCell.data('confirming', true);

    // Создаем контейнер для кнопок "Да" и "Нет"
    var buttonsContainer = $('<div>').addClass('confirm-buttons');

    var yesButton = $('<button>')
        .text('Да')
        .addClass('confirm-yes-button btn btn-success btn-sm me-2')
        .click(function() {
            deleteConfirmed(rowId);
        });

    var noButton = $('<button>')
        .text('Нет')
        .addClass('confirm-no-button btn btn-secondary btn-sm')
        .click(function() {
            cancelDeleteConfirmation(rowId);
        });

    buttonsContainer.append(yesButton);
    buttonsContainer.append(noButton);

    // Заменяем содержимое ячейки на контейнер с кнопками
    deleteCell.empty();
    deleteCell.append(buttonsContainer);
}

function deleteConfirmed(rowId) {
    $.ajax({
        url: '/delete_row',
        type: 'POST',
        contentType: 'application/json',
        data: JSON.stringify({ id: rowId }),
        success: function(response) {
            if (response.status === 'success') {
                // Удаляем строку из таблицы
                $(`tr[data-id='${rowId}']`).remove();
                console.log(`Row with ID ${rowId} deleted successfully.`);

                // Обновляем статистику после удаления записи
                updateStatistics();
            } else {
                console.error('Ошибка при удалении записи:', response.message);
                // Можно добавить уведомление пользователю о неудаче
            }
            // Восстанавливаем кнопку "Удалить" и сбрасываем флаг
            cancelDeleteConfirmation(rowId);
        },
        error: function(xhr, status, error) {
            console.error('Произошла ошибка при удалении записи:', error);
            // Можно добавить уведомление пользователю о неудаче
            // Восстанавливаем кнопку "Удалить" и сбрасываем флаг
            cancelDeleteConfirmation(rowId);
        }
    });
}

function cancelDeleteConfirmation(rowId) {
    var deleteCell = $(`tr[data-id='${rowId}'] td:last-child`);
    // Сбрасываем флаг подтверждения
    deleteCell.data('confirming', false);
    // Восстанавливаем кнопку "Удалить"
    deleteCell.empty();
    var deleteButton = $('<button>')
        .text('Удалить')
        .addClass('delete-button btn btn-danger btn-sm')
        .click(function() {
            initiateDeleteConfirmation(rowId);
        });
    deleteCell.append(deleteButton);

    isDeleting = false; // Сбрасываем глобальный флаг
}

function loadCurrentDL() {
    const selectedDate = getSelectedDate();
    $.ajax({
        url: '/get_current_dl',
        type: 'GET',
        data: { date: selectedDate },
        success: function(response) {
            if (response.status === 'success') {
                $('#initial-dl').val(response.current_dl);
            } else {
                $('#initial-dl').val(''); // Можно установить значение по умолчанию или показать сообщение
                console.warn(response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('Ошибка при получении текущего DL:', error);
            $('#initial-dl').val('');
        }
    });
}

function markUnpackedDays(year, month, force = false) {
    const key = `${year}-${String(month).padStart(2, '0')}`;

    if (!force && unpackedDaysCache[key] !== undefined) {
        fpInstance.redraw(); // Перерисовываем календарь для применения стилей
        return;
    }

    // Запрашиваем неупакованные дни для выбранного месяца и года
    fetch(`/get_unpacked_days?year=${year}&month=${month}`)
        .then(response => response.json())
        .then(data => {
            if (data.status === 'success') {
                unpackedDaysCache[key] = new Set(data.unpacked_days);
                console.log(`Неупакованные дни для ${key}:`, unpackedDaysCache[key]);
            } else {
                console.error('Ошибка при получении неупакованных дней:', data.message);
                unpackedDaysCache[key] = new Set(); // Инициализируем пустым множеством
            }
            fpInstance.redraw(); // Перерисовываем календарь после обновления данных
        })
        .catch(error => {
            console.error('Ошибка при запросе неупакованных дней:', error);
            unpackedDaysCache[key] = new Set(); // Инициализируем пустым множеством
            fpInstance.redraw();
        });
}
document.addEventListener("DOMContentLoaded", function() {
    flatpickr("#datepicker", {
        dateFormat: "Y-m-d",
        onMonthChange: function(selectedDates, dateStr, instance) {
            // Получаем дни, которые нужно выделить
            fetch(`/get_unpacked_days?year=${instance.currentYear}&month=${instance.currentMonth + 1}`)
                .then(response => response.json())
                .then(data => {
                    instance.set("disable", []);
                    instance.set("enable", []);
                    instance.set("marked", data.unpacked_days.map(day => {
                        return `${instance.currentYear}-${instance.currentMonth + 1}-${day}`;
                    }));
                });
        }
    });
});
function loadRpaCounts(year, month) {
    fetch(`/get_rpa_counts?year=${year}&month=${month}`)
        .then(response => response.json())
        .then(data => {
            if (data.status === 'success') {
                const rpaCounts = data.rpa_counts;
                fpInstance.redraw(); // Перерисовываем календарь

                // Обновляем количество записей RPA для каждого дня
                fpInstance.days.childNodes.forEach(dayElem => {
                    const dateStr = dayElem.dateObj.toISOString().split('T')[0];
                    if (rpaCounts[dateStr]) {
                        dayElem.classList.add('has-rpa-records');
                        dayElem.setAttribute('data-rpa-count', rpaCounts[dateStr]);
                    } else {
                        dayElem.classList.remove('has-rpa-records');
                        dayElem.removeAttribute('data-rpa-count');
                    }
                });

                // Сохраняем количество записей RPA в экземпляре flatpickr
                fpInstance.rpaCounts = rpaCounts;
            } else {
                console.error('Ошибка при получении количества записей RPA:', data.message);
            }
        })
        .catch(error => {
            console.error('Ошибка при запросе количества записей RPA:', error);
        });
}

// Обновляем количество записей RPA при изменении месяца
$('#datepicker').on('change', function() {
    const selectedDate = new Date(fpInstance.selectedDates[0]);
    loadRpaCounts(selectedDate.getFullYear(), selectedDate.getMonth() + 1);
});

// Обновляем количество записей RPA при загрузке страницы
$(document).ready(function() {
    const today = new Date();
    loadRpaCounts(today.getFullYear(), today.getMonth() + 1);
});

// Обновляем количество записей RPA при переходе на другой день
fpInstance.config.onDayCreate = function(dObj, dStr, fp, dayElem) {
    const dateStr = dayElem.dateObj.toISOString().split('T')[0];
    if (fpInstance.rpaCounts && fpInstance.rpaCounts[dateStr]) {
        dayElem.classList.add('has-rpa-records');
        dayElem.setAttribute('data-rpa-count', fpInstance.rpaCounts[dateStr]);
    } else {
        dayElem.classList.remove('has-rpa-records');
        dayElem.removeAttribute('data-rpa-count');
    }
};
$(document).ready(function() {
    // Инициализация календаря
    fpInstance = flatpickr("#datepicker", {
        locale: "ru",
        dateFormat: "Y-m-d",
        defaultDate: "today",
        onChange: function(selectedDates, dateStr, instance) {
            const selectedDate = selectedDates[0];
            if (selectedDate) {
                loadRpaCounts(selectedDate.getFullYear(), selectedDate.getMonth() + 1);
            }
        },
        onMonthChange: function(selectedDates, dateStr, instance) {
            const selectedDate = new Date(dateStr);
            loadRpaCounts(selectedDate.getFullYear(), selectedDate.getMonth() + 1);
        },
        onDayCreate: function(dObj, dStr, fp, dayElem) {
            const dateStr = dayElem.dateObj.toISOString().split('T')[0];
            if (fpInstance.rpaCounts && fpInstance.rpaCounts[dateStr]) {
                dayElem.classList.add('has-rpa-records');
                dayElem.setAttribute('data-rpa-count', fpInstance.rpaCounts[dateStr]);
            } else {
                dayElem.classList.remove('has-rpa-records');
                dayElem.removeAttribute('data-rpa-count');
            }
        }
    });

    // Перетаскивание календаря
    let isDragging = false;
    let dragOffsetX = 0;
    let dragOffsetY = 0;

    $('.flatpickr-calendar').on('mousedown', function(e) {
        isDragging = true;
        dragOffsetX = e.clientX - $(this).offset().left;
        dragOffsetY = e.clientY - $(this).offset().top;
        $(this).css('cursor', 'grabbing');
    });

    $(document).on('mousemove', function(e) {
        if (isDragging) {
            $('.flatpickr-calendar').offset({
                top: e.clientY - dragOffsetY,
                left: e.clientX - dragOffsetX
            });
        }
    });

    $(document).on('mouseup', function() {
        isDragging = false;
        $('.flatpickr-calendar').css('cursor', 'grab');
    });

    // Загрузка данных при загрузке страницы
    const today = new Date();
    loadRpaCounts(today.getFullYear(), today.getMonth() + 1);
});
document.addEventListener('DOMContentLoaded', function() {
    // Инициализация календаря
    const fpInstance = flatpickr("#datepicker", {
        locale: "ru",
        dateFormat: "Y-m-d",
        defaultDate: "today",
        onChange: function(selectedDates, dateStr, instance) {
            updateDLValue(dateStr);
        }
    });

    // Функция для обновления значения DL
    function updateDLValue(dateStr) {
        console.log('Updating DL value for date:', dateStr);
        fetch(`/get_table_data?date=${dateStr}`)
            .then(response => response.json())
            .then(data => {
                if (data.status === 'success') {
                    const rows = data.data;
                    let maxDL = 0;

                    // Ищем максимальное значение DL в таблице
                    rows.forEach(row => {
                        const dlNumber = parseInt(row.dl_number.replace('DL', ''), 10);
                        if (!isNaN(dlNumber) && dlNumber > maxDL) {
                            maxDL = dlNumber;
                        }
                    });

                    // Увеличиваем максимальное значение на единицу
                    const nextDL = maxDL + 1;
                    console.log('Next DL value:', nextDL);
                    document.getElementById('initial-dl').value = `DL${nextDL}`;
                } else {
                    console.warn(data.message);
                }
            })
            .catch(error => {
                console.error('Ошибка при получении данных таблицы:', error);
            });
    }

    // Инициализация значения DL для текущей даты
    const currentDate = new Date().toISOString().split('T')[0];
    updateDLValue(currentDate);
});
document.addEventListener('DOMContentLoaded', function() {
    // Инициализация календаря
    const fpInstance = flatpickr("#datepicker", {
        locale: "ru",
        dateFormat: "Y-m-d",
        defaultDate: "today",
        onChange: function(selectedDates, dateStr, instance) {
            updateStatistics(dateStr);
        }
    });

    // Функция для обновления статистики
    function updateStatistics(dateStr) {
        console.log('Updating statistics for date:', dateStr);
        fetch(`/get_statistics?date=${dateStr}`)
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok ' + response.statusText);
                }
                return response.json();
            })
            .then(data => {
                if (data.status === 'success') {
                    console.log('Received statistics:', data);
                    document.getElementById('generateClicks').textContent = data.generate_clicks;
                    document.getElementById('packClicks').textContent = data.pack_clicks;
                    const unpackedClicks = data.rpa_records - data.pack_clicks;
                    console.log('Unpacked clicks:', unpackedClicks);
                    document.getElementById('unpackedClicks').textContent = unpackedClicks;
                } else {
                    console.warn(data.message);
                }
            })
            .catch(error => {
                console.error('Ошибка при получении статистики:', error);
            });
    }

    // Инициализация статистики для текущей даты
    const currentDate = new Date().toISOString().split('T')[0];
    updateStatistics(currentDate);
});
function loadLastDLNumberAllTime() {
    $.ajax({
        url: '/get_last_dl_number_all_time',
        type: 'GET',
        success: function(response) {
            if (response.status === 'success') {
                $('#initial-dl').val(response.next_dl_number);
            } else {
                console.error('Ошибка при получении крайнего DL за всё время:', response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('Ошибка при запросе крайнего DL за всё время:', error);
        }
    });
}

// Вызываем функцию при загрузке страницы
$(document).ready(function() {
    loadLastDLNumberAllTime();
});
const toggle = document.getElementById("toggle");
const refresh = document.getElementById("refresh");
const theme = window.localStorage.getItem("theme");

/* checks if the theme stored in localStorage is dark
if yes apply the dark theme to the body */
if (theme === "dark") document.body.classList.add("dark");

// event listener stops when the change theme button is clicked
toggle.addEventListener("click", () => {
   document.body.classList.toggle("dark");
   if (theme === "dark") {
     window.localStorage.setItem("theme", "light");
   } else window.localStorage.setItem("theme", "dark");
});

refresh.addEventListener("click", () => {
   window.location.reload();
});
function toggleDeviceStatusWindow() {
    const deviceStatusWindow = $('#deviceStatusWindow');
    if (deviceStatusWindow.hasClass('show')) {
        deviceStatusWindow.removeClass('show');
    } else {
        deviceStatusWindow.addClass('show');
    }
}

$(document).ready(function() {
    // Обработчик для кнопки "Статусы Устройств"
    $('.status-button').on('click', function() {
        toggleDeviceStatusWindow();
    });

    // Обработчик для крестика
    $('.close-button').on('click', function() {
        $('#deviceStatusWindow').removeClass('show');
    });
});
$(document).ready(function() {
    // Обработчик для кнопки "Импорт из Excel"
    $('.import-button').on('click', function() {
        $('#fileInput').click(); // Вызываем клик на скрытом input[type="file"]
    });

    // Обработчик для выбора файла
    $('#fileInput').on('change', function(event) {
        const file = event.target.files[0];
        if (file) {
            const formData = new FormData();
            formData.append('file', file);

            // Отправка файла на сервер
            $.ajax({
                url: '/import_excel', // URL для обработки файла на сервере
                type: 'POST',
                data: formData,
                processData: false,
                contentType: false,
                success: function(response) {
                    if (response.status === 'success') {
                        alert('Файл успешно импортирован');
                        // Обновляем таблицу или выполняем другие действия после импорта
                        updateTable();
                    } else {
                        alert('Ошибка при импорте файла: ' + response.message);
                    }
                },
                error: function(xhr, status, error) {
                    alert('Ошибка при отправке файла: ' + error);
                }
            });
        }
    });
});