package cc.winboll.studio.positions.activities;

/**
 * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
 * @Date 2025/09/29 18:22
 * @Describe 位置列表页面（适配MainService GPS接口+规范服务交互+完善生命周期）
 */
import android.os.Bundle;
import android.os.IBinder;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.widget.Toast;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.adapters.PositionAdapter;
import cc.winboll.studio.positions.models.PositionModel;
import cc.winboll.studio.positions.models.PositionTaskModel;
import cc.winboll.studio.positions.services.MainService;
import cc.winboll.studio.positions.R;
import java.util.ArrayList;

/**
 * Java 7 语法适配：
 * 1. 服务绑定用匿名内部类实现 ServiceConnection
 * 2. Adapter 初始化传入 MainService 实例，确保数据来源唯一
 * 3. 所有位置/任务操作通过 MainService 接口执行
 */
public class LocationActivity extends Activity {
    private static final String TAG = "LocationActivity";

    private RecyclerView mRvPosition;
    private PositionAdapter mPositionAdapter;
    private ArrayList<PositionModel> mLocalPosCache; // 本地位置缓存（与MainService同步）

    // MainService 引用+绑定状态
    private MainService mMainService;
    private boolean isServiceBound = false;

    // 服务连接（Java 7 匿名内部类实现）
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 假设 MainService 用 LocalBinder 暴露实例（Java 7 强转）
            MainService.LocalBinder binder = (MainService.LocalBinder) service;
            mMainService = binder.getService();
            isServiceBound = true;

            LogUtils.d(TAG, "MainService绑定成功，开始同步数据");
            // 从MainService同步初始数据（位置+任务）
            syncDataFromMainService();
            // 初始化Adapter（传入MainService实例，确保任务数据从服务获取）
            initPositionAdapter();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            LogUtils.w(TAG, "MainService断开连接，清空引用");
            mMainService = null;
            isServiceBound = false;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_location);

        // 初始化视图+本地缓存
        initView();
        mLocalPosCache = new ArrayList<PositionModel>();

        // 绑定MainService（确保Activity启动时就拿到服务实例）
        bindMainService();
    }

    /**
     * 初始化视图（RecyclerView）
     */
    private void initView() {
        mRvPosition = (RecyclerView) findViewById(R.id.rv_position_list);
        // Java 7 显式设置布局管理器（LinearLayoutManager）
        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
        layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
        mRvPosition.setLayoutManager(layoutManager);
    }

    /**
     * 绑定MainService（Java 7 显式Intent）
     */
    private void bindMainService() {
        Intent serviceIntent = new Intent(this, MainService.class);
        // 绑定服务（BIND_AUTO_CREATE：服务不存在时自动创建）
        bindService(serviceIntent, mServiceConnection, BIND_AUTO_CREATE);
        LogUtils.d(TAG, "发起MainService绑定请求");
    }

    /**
     * 从MainService同步数据（位置+任务）
     */
    private void syncDataFromMainService() {
        if (!isServiceBound || mMainService == null) {
            LogUtils.w(TAG, "同步数据失败：MainService未绑定");
            showToast("服务未就绪，无法加载数据");
            return;
        }

        // 同步位置数据（从服务获取最新列表）
        ArrayList<PositionModel> servicePosList = mMainService.getPositionList();
        if (servicePosList != null && !servicePosList.isEmpty()) {
            mLocalPosCache.clear();
            mLocalPosCache.addAll(servicePosList);
            LogUtils.d(TAG, "从MainService同步位置数据完成：数量=" + mLocalPosCache.size());
        }

        // 同步任务数据（无需本地缓存，Adapter直接从服务获取）
        ArrayList<PositionTaskModel> serviceTaskList = mMainService.getAllTasks();
        LogUtils.d(TAG, "从MainService同步任务数据完成：数量=" + serviceTaskList.size());
    }

    /**
     * 初始化PositionAdapter（核心：传入MainService实例）
     */
    private void initPositionAdapter() {
        if (mMainService == null) {
            LogUtils.e(TAG, "初始化Adapter失败：MainService为空");
            return;
        }

        // Java 7 显式初始化Adapter，传入上下文+本地位置缓存+MainService实例
        mPositionAdapter = new PositionAdapter(this, mLocalPosCache, mMainService);

        // 设置Adapter回调（处理位置删除/保存，最终同步到MainService）
        mPositionAdapter.setOnDeleteClickListener(new PositionAdapter.OnDeleteClickListener() {
				@Override
				public void onDeleteClick(int position) {
					// 删除逻辑：先删本地缓存，再调用MainService接口删服务数据
					if (position < 0 || position >= mLocalPosCache.size()) {
						LogUtils.w(TAG, "删除位置失败：无效索引=" + position);
						return;
					}
					PositionModel deletePos = mLocalPosCache.get(position);
					if (deletePos != null && !deletePos.getPositionId().isEmpty()) {
						// 1. 调用MainService接口删除服务端数据
						mMainService.removePosition(deletePos.getPositionId());
						// 2. 删除本地缓存数据
						mLocalPosCache.remove(position);
						// 3. 通知Adapter刷新
						mPositionAdapter.notifyItemRemoved(position);
						showToast("删除位置成功：" + deletePos.getMemo());
						LogUtils.d(TAG, "删除位置完成：ID=" + deletePos.getPositionId() + "（已同步MainService）");
					}
				}
			});

        mPositionAdapter.setOnSavePositionClickListener(new PositionAdapter.OnSavePositionClickListener() {
				@Override
				public void onSavePositionClick(int position, PositionModel updatedPos) {
					// 保存逻辑：先更本地缓存，再调用MainService接口更新服务数据
					if (!isServiceBound || mMainService == null) {
						LogUtils.w(TAG, "保存位置失败：MainService未绑定");
						showToast("服务未就绪，保存失败");
						return;
					}
					if (position < 0 || position >= mLocalPosCache.size()) {
						LogUtils.w(TAG, "保存位置失败：无效索引=" + position);
						return;
					}

					// 1. 调用MainService接口更新服务端数据
					mMainService.updatePosition(updatedPos);
					// 2. 更新本地缓存数据
					mLocalPosCache.set(position, updatedPos);
					// 3. 通知Adapter刷新（可选，Adapter已本地同步）
					mPositionAdapter.notifyItemChanged(position);
					showToast("保存位置成功：" + updatedPos.getMemo());
					LogUtils.d(TAG, "保存位置完成：ID=" + updatedPos.getPositionId() + "（已同步MainService）");
				}
			});

        // 设置Adapter到RecyclerView
        mRvPosition.setAdapter(mPositionAdapter);
        LogUtils.d(TAG, "PositionAdapter初始化完成（已绑定MainService）");
    }

    /**
     * 显示Toast（Java 7 显式Toast.makeText）
     */
    private void showToast(String content) {
        Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 1. 释放Adapter资源（反注册服务监听，避免内存泄漏）
        if (mPositionAdapter != null) {
            mPositionAdapter.release();
        }

        // 2. 解绑MainService（避免Activity销毁后服务仍被持有）
        if (isServiceBound) {
            unbindService(mServiceConnection);
            LogUtils.d(TAG, "MainService解绑完成");
        }
    }
	
	public static class LocalBinder extends android.os.Binder {
        // 持有 MainService 实例引用
        private MainService mService;

        // 构造时传入服务实例
        public LocalBinder(MainService service) {
            this.mService = service;
        }

        // 对外提供获取服务实例的方法（供Activity调用）
        public MainService getService() {
            return mService;
        }
    }
}

