package com.grigowashere.aismap.view;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.util.Log;
import com.grigowashere.aismap.models.Vessel;

public class CoordinatesDockWidget extends BaseDockWidget {
    private static final String TAG = "CoordinatesDockWidget";
    
    // Цвета
    private static final int BACKGROUND_COLOR = 0xE6000000; // Полупрозрачный черный
    private static final int TEXT_COLOR = 0xFFFFFFFF; // Белый
    private static final int ACCENT_COLOR = 0xFF4CAF50; // Зеленый
    private static final int WARNING_COLOR = 0xFFFF9800; // Оранжевый
    private static final int ERROR_COLOR = 0xFFF44336; // Красный
    
    // Кисти
    private Paint backgroundPaint;
    private Paint textPaint;
    private Paint accentPaint;
    private Paint warningPaint;
    private Paint errorPaint;
    
    // Данные для отображения
    private Vessel vessel;
    private String coordinatesText = "Координаты: --";
    private String sogText = "SOG: --";
    private String cogText = "COG: --";
    
    public CoordinatesDockWidget(Context context) {
        super(context);
        init();
    }
    
    public CoordinatesDockWidget(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }
    
    private void init() {
        // Инициализируем кисти
        backgroundPaint = new Paint();
        backgroundPaint.setColor(BACKGROUND_COLOR);
        backgroundPaint.setStyle(Paint.Style.FILL);
        backgroundPaint.setAntiAlias(true);
        
        textPaint = new Paint();
        textPaint.setColor(TEXT_COLOR);
        textPaint.setTextSize(dp(14));
        textPaint.setTypeface(Typeface.DEFAULT_BOLD);
        textPaint.setAntiAlias(true);
        
        accentPaint = new Paint();
        accentPaint.setColor(ACCENT_COLOR);
        accentPaint.setTextSize(dp(14));
        accentPaint.setTypeface(Typeface.DEFAULT_BOLD);
        accentPaint.setAntiAlias(true);
        
        warningPaint = new Paint();
        warningPaint.setColor(WARNING_COLOR);
        warningPaint.setTextSize(dp(14));
        warningPaint.setTypeface(Typeface.DEFAULT_BOLD);
        warningPaint.setAntiAlias(true);
        
        errorPaint = new Paint();
        errorPaint.setColor(ERROR_COLOR);
        errorPaint.setTextSize(dp(14));
        errorPaint.setTypeface(Typeface.DEFAULT_BOLD);
        errorPaint.setAntiAlias(true);
        
        // Устанавливаем фон для видимости (как в CompassView)
        setBackgroundColor(android.graphics.Color.argb(200, 0, 0, 0));
    }
    
    /**
     * Обновляет данные судна
     */
    public void updateVessel(Vessel vessel) {
        Log.d(TAG, "updateVessel called with vessel: " + (vessel != null ? "not null" : "null"));
        if (vessel != null) {
            Log.d(TAG, "Vessel data: lat=" + vessel.getLatitude() + 
                  ", lon=" + vessel.getLongitude() + 
                  ", speed=" + vessel.getSpeed() + 
                  ", course=" + vessel.getCourse());
        }
        this.vessel = vessel;
        updateDisplayText();
        invalidate();
    }
    
    /**
     * Обновляет текст для отображения
     */
    private void updateDisplayText() {
        if (vessel == null) {
            coordinatesText = "Координаты: --";
            sogText = "SOG: --";
            cogText = "COG: --";
            return;
        }
        
        // Координаты
        if (vessel.getLatitude() != 0 && vessel.getLongitude() != 0) {
            coordinatesText = String.format("📍 %.6f, %.6f", 
                vessel.getLatitude(), vessel.getLongitude());
        } else {
            coordinatesText = "📍 Координаты: --";
        }
        
        // SOG (Speed Over Ground)
        if (vessel.getSpeed() > 0) {
            sogText = String.format("⚡ SOG: %.1f уз", vessel.getSpeed());
        } else {
            sogText = "⚡ SOG: --";
        }
        
        // COG (Course Over Ground)
        if (vessel.getCourse() > 0) {
            cogText = String.format("🧭 COG: %.1f°", vessel.getCourse());
        } else {
            cogText = "🧭 COG: --";
        }
    }
    
    @Override
    protected void onDrawDock(Canvas canvas) {
        int width = getWidth();
        int height = getHeight();
        
        Log.d(TAG, "onDrawDock called, width=" + width + ", height=" + height);
        
        if (width <= 0 || height <= 0) {
            Log.w(TAG, "Invalid dimensions: width=" + width + ", height=" + height);
            return;
        }
        
        // Рисуем фон
        canvas.drawRect(0, 0, width, height, backgroundPaint);
        
        // Вычисляем позиции для текста
        float textSize = dp(14);
        float lineHeight = textSize * 1.2f;
        float startY = (height - (lineHeight * 3)) / 2 + textSize;
        
        // Определяем цвета в зависимости от качества данных
        Paint coordinatesPaint = getCoordinatesPaint();
        Paint sogPaint = getSOGPaint();
        Paint cogPaint = getCOGPaint();
        
        // Рисуем тестовый заголовок для проверки видимости
        Paint testPaint = new Paint();
        testPaint.setColor(android.graphics.Color.WHITE);
        testPaint.setTextSize(dp(16));
        testPaint.setTypeface(android.graphics.Typeface.DEFAULT_BOLD);
        testPaint.setAntiAlias(true);
        canvas.drawText("КООРДИНАТЫ", dp(16), dp(20), testPaint);
        
        // Рисуем текст
        canvas.drawText(coordinatesText, dp(16), startY, coordinatesPaint);
        canvas.drawText(sogText, dp(16), startY + lineHeight, sogPaint);
        canvas.drawText(cogText, dp(16), startY + lineHeight * 2, cogPaint);
        
        // Рисуем разделительную линию сверху, если закреплен снизу
        if (!isDockTop()) {
            Paint linePaint = new Paint();
            linePaint.setColor(ACCENT_COLOR);
            linePaint.setStrokeWidth(dp(2));
            canvas.drawLine(0, 0, width, 0, linePaint);
        }
    }
    
    @Override
    protected void onDrawCircle(Canvas canvas) {
        int width = getWidth();
        int height = getHeight();
        int centerX = width / 2;
        int centerY = height / 2;
        int radius = Math.min(width, height) / 2 - (int)dp(8);
        
        // Рисуем фон
        canvas.drawCircle(centerX, centerY, radius, backgroundPaint);
        
        // Рисуем рамку
        Paint borderPaint = new Paint();
        borderPaint.setColor(ACCENT_COLOR);
        borderPaint.setStyle(Paint.Style.STROKE);
        borderPaint.setStrokeWidth(dp(3));
        borderPaint.setAntiAlias(true);
        canvas.drawCircle(centerX, centerY, radius, borderPaint);
        
        // Вычисляем позиции для текста в круге
        float textSize = dp(12);
        float lineHeight = textSize * 1.3f;
        float startY = centerY - lineHeight;
        
        // Определяем цвета
        Paint coordinatesPaint = getCoordinatesPaint();
        Paint sogPaint = getSOGPaint();
        Paint cogPaint = getCOGPaint();
        
        // Центрируем текст
        Rect textBounds = new Rect();
        
        // Координаты
        coordinatesPaint.getTextBounds(coordinatesText, 0, coordinatesText.length(), textBounds);
        canvas.drawText(coordinatesText, centerX - textBounds.width() / 2f, startY, coordinatesPaint);
        
        // SOG
        sogPaint.getTextBounds(sogText, 0, sogText.length(), textBounds);
        canvas.drawText(sogText, centerX - textBounds.width() / 2f, startY + lineHeight, sogPaint);
        
        // COG
        cogPaint.getTextBounds(cogText, 0, cogText.length(), textBounds);
        canvas.drawText(cogText, centerX - textBounds.width() / 2f, startY + lineHeight * 2, cogPaint);
    }
    
    /**
     * Определяет цвет для отображения координат
     */
    private Paint getCoordinatesPaint() {
        if (vessel == null || vessel.getLatitude() == 0 || vessel.getLongitude() == 0) {
            return errorPaint;
        }
        
        // Проверяем точность GPS
        if (vessel.getAccuracy() > 0) {
            if (vessel.getAccuracy() <= 5) {
                return accentPaint; // Высокая точность - зеленый
            } else if (vessel.getAccuracy() <= 20) {
                return warningPaint; // Средняя точность - оранжевый
            } else {
                return errorPaint; // Низкая точность - красный
            }
        }
        
        return textPaint; // По умолчанию - белый
    }
    
    /**
     * Определяет цвет для отображения SOG
     */
    private Paint getSOGPaint() {
        if (vessel == null || vessel.getSpeed() <= 0) {
            return errorPaint;
        }
        
        return accentPaint; // Если есть данные о скорости - зеленый
    }
    
    /**
     * Определяет цвет для отображения COG
     */
    private Paint getCOGPaint() {
        if (vessel == null || vessel.getCourse() <= 0) {
            return errorPaint;
        }
        
        return accentPaint; // Если есть данные о курсе - зеленый
    }
    
    /**
     * Получает высоту виджета в dock-режиме
     */
    public int getDockHeight() {
        if (isDocked()) {
            return getHeight();
        }
        return (int) dp(DEFAULT_DOCK_HEIGHT_DP);
    }
}
