package com.mc.bleapp

import android.annotation.SuppressLint
import android.bluetooth.*
import android.bluetooth.le.ScanCallback
import android.bluetooth.le.ScanResult
import android.content.ClipboardManager
import android.content.Context
import android.content.pm.PackageManager
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.widget.Button
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import java.util.*

class MainActivity : AppCompatActivity() {

    private lateinit var statusText: TextView
    private lateinit var logText: TextView
    private lateinit var sendButton: Button
    private lateinit var reconnectButton: Button

    private val DEVICE_NAME = "Secure BLE Keyboard"
    private val SERVICE_UUID = UUID.fromString("4fafc201-1fb5-459e-8fcc-c5c9c331914b")
    private val INPUT_CHAR_UUID = UUID.fromString("beb5483e-36e1-4688-b7f5-ea07361b26a8")

    private var bluetoothAdapter: BluetoothAdapter? = null
    private var bluetoothGatt: BluetoothGatt? = null
    private var inputCharacteristic: BluetoothGattCharacteristic? = null
    private var isConnected = false

    private val handler = Handler(Looper.getMainLooper())
    private val PERMISSIONS = arrayOf(
        android.Manifest.permission.ACCESS_FINE_LOCATION,
        android.Manifest.permission.BLUETOOTH,
        android.Manifest.permission.BLUETOOTH_ADMIN,
        android.Manifest.permission.BLUETOOTH_CONNECT,
        android.Manifest.permission.BLUETOOTH_SCAN
    )

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        statusText = findViewById(R.id.statusText)
        logText = findViewById(R.id.logText)
        sendButton = findViewById(R.id.sendButton)
        reconnectButton = findViewById(R.id.reconnectButton)

        reconnectButton.setOnClickListener { reconnect() }
        sendButton.setOnClickListener { sendClipboardContent() }
        checkPermissions()
    }

    private fun checkPermissions() {
        if (PERMISSIONS.any { ContextCompat.checkSelfPermission(this, it) != PackageManager.PERMISSION_GRANTED }) {
            ActivityCompat.requestPermissions(this, PERMISSIONS, 0)
        } else {
            initializeBluetooth()
        }
    }

    @SuppressLint("MissingPermission")
    private fun initializeBluetooth() {
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter().takeIf { it.isEnabled }
            ?: run {
                Toast.makeText(this, "Enable Bluetooth", Toast.LENGTH_LONG).show()
                return
            }
        startDeviceScan()
    }

    @SuppressLint("MissingPermission")
    private fun startDeviceScan() {
        statusText.text = "Scanning..."
        bluetoothAdapter?.bluetoothLeScanner?.startScan(scanCallback)
        handler.postDelayed({ stopScan() }, 10000)
    }

    private fun stopScan() {
        bluetoothAdapter?.bluetoothLeScanner?.stopScan(scanCallback)
    }

    private val scanCallback = object : ScanCallback() {
        @SuppressLint("MissingPermission")
        override fun onScanResult(callbackType: Int, result: ScanResult) {
            if (result.device.name == DEVICE_NAME) {
                stopScan()
                connectToDevice(result.device)
            }
        }
    }

    @SuppressLint("MissingPermission")
    private fun connectToDevice(device: BluetoothDevice) {
        statusText.text = "Connecting..."
        bluetoothGatt = device.connectGatt(this, false, gattCallback)
    }

    private val gattCallback = object : BluetoothGattCallback() {
        @SuppressLint("MissingPermission")
        override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
            when (newState) {
                BluetoothProfile.STATE_CONNECTED -> {
                    isConnected = true
                    handler.post {
                        statusText.text = "Connected"
                        log("Connected")
                    }
                    gatt.discoverServices()
                }
                BluetoothProfile.STATE_DISCONNECTED -> {
                    isConnected = false
                    handler.post {
                        statusText.text = "Disconnected"
                        log("Connection lost")
                    }
                }
            }
        }

        override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                inputCharacteristic = gatt.getService(SERVICE_UUID)
                    ?.getCharacteristic(INPUT_CHAR_UUID)

                handler.post {
                    if (inputCharacteristic != null) {
                        log("Service found")
                        sendButton.isEnabled = true
                    } else {
                        log("Service not found")
                    }
                }
            }
        }
    }

    private fun sendClipboardContent() {
        if (!isConnected) {
            Toast.makeText(this, "Not connected", Toast.LENGTH_SHORT).show()
            return
        }

        val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
        clipboard.primaryClip?.getItemAt(0)?.text?.toString()?.let { text ->
            if (text.isNotEmpty()) sendData(text)
        } ?: Toast.makeText(this, "Clipboard empty", Toast.LENGTH_SHORT).show()
    }

    @SuppressLint("MissingPermission")
    private fun sendData(text: String) {
        inputCharacteristic?.let {
            it.value = text.toByteArray()
            bluetoothGatt?.writeCharacteristic(it)
            log("Sent: ${text.take(20)}...")
        } ?: log("Characteristic null")
    }

    private fun log(message: String) {
        logText.append("\n$message")
    }

    @SuppressLint("MissingPermission")
    private fun reconnect() {
        log("Reconnect...")
        bluetoothGatt?.disconnect()
        bluetoothGatt?.close()
        bluetoothGatt = null
        inputCharacteristic = null
        sendButton.isEnabled = false
        startDeviceScan()
    }

    override fun onDestroy() {
        super.onDestroy()
        bluetoothGatt?.disconnect()
        bluetoothGatt?.close()
    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/statusText"
        android:layout_marginTop="20dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Status: Disconnected"
        android:textSize="18sp"/>

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Log:"
        android:textSize="16sp"/>

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1">

        <TextView
            android:id="@+id/logText"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:textSize="14sp"/>
    </ScrollView>

    <Button
        android:id="@+id/reconnectButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Переподключиться"/>

    <Button
        android:id="@+id/sendButton"
        android:layout_width="match_parent"
        android:layout_height="87dp"
        android:enabled="false"
        android:text="Отправить"/>
</LinearLayout>

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.mc.bleapp">

    <uses-permission android:name="android.permission.BLUETOOTH"/>
    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"/>
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
    <uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>

    <application
        android:theme="@style/Theme.AppCompat.DayNight.DarkActionBar"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="BLE Keyboard">

        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

#include <USB.h>
#include <USBHIDKeyboard.h>

USBHIDKeyboard Keyboard;

void setup() {
  USB.begin();
  Keyboard.begin();
  delay(2000); // Дать время для подключения USB
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press(KEY_ALT);
  Keyboard.press('t');
  Keyboard.releaseAll(); // Отправка Ctrl+Alt+T (открыть терминал в Linux)
}

void loop() {}

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>
#include <USB.h>
#include <USBHIDKeyboard.h>

USBHIDKeyboard Keyboard;

#define DEVICE_NAME "Secure BLE Keyboard"
#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
const uint32_t PIN_CODE = 123456;

bool deviceConnected = false;

class CharacteristicCallbacks : public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) override {
        String arduinoString = pCharacteristic->getValue().c_str(); 
        std::string value(arduinoString.c_str());
        
        if (!value.empty()) {
            Serial.print("Received: ");
            Serial.println(value.c_str());
            
            // Отправка текста через USB HID
            for (char c : value) {
                Keyboard.press(c); // Нажать клавишу
                delay(10);         // Короткая задержка
                Keyboard.release(c); // Отпустить клавишу
            }
        }
    }
};

class ServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) override {
        deviceConnected = true;
        Serial.println("Device connected");
    };

    void onDisconnect(BLEServer* pServer) override {
        deviceConnected = false;
        Serial.println("Device disconnected");
        pServer->startAdvertising();
    }
};

class SecurityCallbacks: public BLESecurityCallbacks {
    bool onConfirmPIN(uint32_t pass_key) override {
        Serial.print("Confirm PIN: ");
        Serial.println(pass_key);
        return (pass_key == PIN_CODE);
    }

    void onAuthenticationComplete(esp_ble_auth_cmpl_t cmpl) override {
        if(cmpl.success) {
            Serial.println("Authentication success");
        } else {
            Serial.println("Authentication failed");
        }
    }

    uint32_t onPassKeyRequest() override {
        return PIN_CODE;
    }

    void onPassKeyNotify(uint32_t pass_key) override {
        Serial.print("PassKey Notify: ");
        Serial.println(pass_key);
    }

    bool onSecurityRequest() override {
        return true;
    }
};

void setup() {
    Serial.begin(115200);
    USB.begin();
    Keyboard.begin();
    delay(2000); // Дать время для подключения USB
    BLEDevice::init(DEVICE_NAME);
    BLEDevice::setEncryptionLevel(ESP_BLE_SEC_ENCRYPT);
    
    BLEServer *pServer = BLEDevice::createServer();
    pServer->setCallbacks(new ServerCallbacks());
    
    BLESecurity *pSecurity = new BLESecurity();
    pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_BOND);
    pSecurity->setCapability(ESP_IO_CAP_OUT);
    pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
    BLEDevice::setSecurityCallbacks(new SecurityCallbacks());

    esp_ble_gap_set_security_param(
        ESP_BLE_SM_SET_STATIC_PASSKEY,
        const_cast<uint32_t*>(reinterpret_cast<const uint32_t*>(&PIN_CODE)),
        sizeof(PIN_CODE)
    );

    BLEService *pService = pServer->createService(SERVICE_UUID);
    BLECharacteristic *pCharacteristic = pService->createCharacteristic(
        CHARACTERISTIC_UUID,
        BLECharacteristic::PROPERTY_READ |
        BLECharacteristic::PROPERTY_WRITE
    );

    // Добавлен обработчик входящих данных
    pCharacteristic->setCallbacks(new CharacteristicCallbacks());
    
    pCharacteristic->setValue("Hello World");
    pCharacteristic->addDescriptor(new BLE2902());
    pService->start();

    BLEAdvertising *pAdvertising = pServer->getAdvertising();
    pAdvertising->addServiceUUID(SERVICE_UUID);
    pAdvertising->start();
}

void loop() {
    delay(1000);
}