package cc.winboll.studio.powerbell.activities;

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.View;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import cc.winboll.studio.libaes.views.AToolbar;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.libappbase.utils.ToastUtils;
import cc.winboll.studio.powerbell.App;
import cc.winboll.studio.powerbell.R;
import cc.winboll.studio.powerbell.beans.BackgroundPictureBean;
import cc.winboll.studio.powerbell.dialogs.BackgroundPicturePreviewDialog;
import cc.winboll.studio.powerbell.utils.BackgroundPictureUtils;
import cc.winboll.studio.powerbell.utils.FileUtils;
import cc.winboll.studio.powerbell.utils.UriUtil;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class BackgroundPictureActivity extends WinBoLLActivity implements BackgroundPicturePreviewDialog.IOnRecivedPictureListener {

    public static final String TAG = "BackgroundPictureActivity";
    public BackgroundPictureUtils mBackgroundPictureUtils;

    // 图片选择请求码
    public static final int REQUEST_SELECT_PICTURE = 0;
    public static final int REQUEST_TAKE_PHOTO = 1;
    public static final int REQUEST_CROP_IMAGE = 2;
    private static final int STORAGE_PERMISSION_REQUEST = 100;

    private AToolbar mAToolbar;
    private File mfBackgroundDir;       // 背景图片存储文件夹
    private File mfPictureDir;          // 拍照与剪裁临时文件夹
    private File mfTakePhoto;           // 拍照文件
    private File mfRecivedPicture;      // 接收的图片文件
    private File mfTempCropPicture;     // 剪裁临时文件
    private File mfRecivedCropPicture;  // 剪裁后的目标文件

    // 静态变量
    public static String _mszRecivedCropPicture = "RecivedCrop.jpg";
    private static String _mszCommonFileType = "jpeg";
    private int mnPictureCompress = 100;
    private static String _RecivedPictureFileName;

	@Override
	public Activity getActivity() {
		return this;
	}

	@Override
	public String getTag() {
		return TAG;
	}

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

        // 初始化工具类和文件夹
        mBackgroundPictureUtils = BackgroundPictureUtils.getInstance(this);
        mfBackgroundDir = new File(mBackgroundPictureUtils.getBackgroundDir());
        if (!mfBackgroundDir.exists()) {
            mfBackgroundDir.mkdirs();
        }

        mfPictureDir = new File(App.getTempDirPath());
        if (!mfPictureDir.exists()) {
            mfPictureDir.mkdirs();
        }

        // 初始化文件对象
        mfTakePhoto = new File(mfPictureDir, "TakePhoto.jpg");
        mfTempCropPicture = new File(mfPictureDir, "TempCrop.jpg");

        mfRecivedPicture = getRecivedPictureFile(this);
        mfRecivedCropPicture = new File(mfBackgroundDir, _mszRecivedCropPicture);

        // 初始化工具栏
        mAToolbar = (AToolbar) findViewById(R.id.toolbar);
        setActionBar(mAToolbar);
        mAToolbar.setSubtitle(R.string.subtitle_activity_backgroundpicture);
        getActionBar().setDisplayHomeAsUpEnabled(true);
        mAToolbar.setNavigationOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    finish();
                }
            });

        // 设置按钮点击事件
        findViewById(R.id.activitybackgroundpictureAButton5).setOnClickListener(onOriginNullClickListener);
        findViewById(R.id.activitybackgroundpictureAButton4).setOnClickListener(onReceivedPictureClickListener);
        findViewById(R.id.activitybackgroundpictureAButton1).setOnClickListener(onTakePhotoClickListener);
        findViewById(R.id.activitybackgroundpictureAButton2).setOnClickListener(onSelectPictureClickListener);
        findViewById(R.id.activitybackgroundpictureAButton3).setOnClickListener(onCropPictureClickListener);
        findViewById(R.id.activitybackgroundpictureAButton6).setOnClickListener(onCropFreePictureClickListener);
		findViewById(R.id.activitybackgroundpictureAButton7).setOnClickListener(onPixelPickerClickListener);
		findViewById(R.id.activitybackgroundpictureAButton8).setOnClickListener(onCleanPixelClickListener);

        updatePreviewBackground();

        // 处理分享的图片
        Intent intent = getIntent();
        String action = intent.getAction();
        String type = intent.getType();

        if (Intent.ACTION_SEND.equals(action) && type != null && isImageType(type)) {
            BackgroundPicturePreviewDialog dlg = new BackgroundPicturePreviewDialog(this);
            dlg.show();
        }
    }

    private void initEnv() {
        LogUtils.d(TAG, "initEnv()");
        _RecivedPictureFileName = "Recived.data";
    }

    public static String getBackgroundFileName() {
        return _mszRecivedCropPicture;
    }

    @Override
    public void onAcceptRecivedPicture(String szPreRecivedPictureName) {
        BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(this);
        utils.getBackgroundPictureBean().setIsUseBackgroundFile(true);
        utils.saveData();

        File sourceFile = new File(utils.getBackgroundDir(), szPreRecivedPictureName);
        if (FileUtils.copyFile(sourceFile, mfRecivedPicture)) {
            startCropImageActivity(false);
        } else {
            ToastUtils.show("图片复制失败，请重试");
        }
    }

    /**
     * 更新背景图片预览
     */
    public void updatePreviewBackground() {
        LogUtils.d(TAG, "updatePreviewBackground");
        ImageView ivPreviewBackground = (ImageView) findViewById(R.id.activitybackgroundpictureImageView1);
        BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(this);
        utils.loadBackgroundPictureBean();

        boolean isUseBackgroundFile = utils.getBackgroundPictureBean().isUseBackgroundFile();
        if (isUseBackgroundFile && mfRecivedCropPicture.exists()) {
            try {
                String filePath = utils.getBackgroundDir() + getBackgroundFileName();
                Drawable drawable = FileUtils.getImageDrawable(filePath);
                if (drawable != null) {
                    //drawable.setAlpha(120);
                    ivPreviewBackground.setImageDrawable(drawable);
                }
                //ToastUtils.show("背景图片已更新");
            } catch (IOException e) {
                LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
                ToastUtils.show("背景图片加载失败");
            }
        } else {
            ToastUtils.show("未使用背景图片");
            Drawable drawable = getResources().getDrawable(R.drawable.blank10x10);
            if (drawable != null) {
                drawable.setAlpha(120);
                ivPreviewBackground.setImageDrawable(drawable);
            }
        }
    }

    // 点击事件监听器
    private View.OnClickListener onOriginNullClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(BackgroundPictureActivity.this);
            BackgroundPictureBean bean = utils.getBackgroundPictureBean();
            bean.setIsUseBackgroundFile(false);
            utils.saveData();
            updatePreviewBackground();
        }
    };

    private View.OnClickListener onSelectPictureClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (checkAndRequestStoragePermission()) {
                Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                startActivityForResult(intent, REQUEST_SELECT_PICTURE);
            }
        }
    };

    private View.OnClickListener onCropPictureClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            File fCheck = new File(mfBackgroundDir, getBackgroundFileName());
            if (fCheck.exists()) {
                startCropImageActivity(false);
            } else {
                ToastUtils.show("没有可剪裁的图片");
            }
        }
    };

    private View.OnClickListener onCropFreePictureClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            File fCheck = new File(mfBackgroundDir, getBackgroundFileName());
            if (fCheck.exists()) {
                startCropImageActivity(true);
            } else {
                ToastUtils.show("没有可剪裁的图片");
            }
        }
    };

    private View.OnClickListener onTakePhotoClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            LogUtils.d(TAG, "onTakePhotoClickListener");
            LogUtils.d(TAG, "mfTakePhoto : " + mfTakePhoto.getPath());

            if (mfTakePhoto.exists()) {
                mfTakePhoto.delete();
            }
            try {
                mfTakePhoto.createNewFile();
            } catch (IOException e) {
                LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
                ToastUtils.show("拍照文件创建失败");
                return;
            }

            if (checkAndRequestStoragePermission()) {
                Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                startActivityForResult(takePictureIntent, REQUEST_TAKE_PHOTO);
            }
        }
    };

    private View.OnClickListener onReceivedPictureClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(BackgroundPictureActivity.this);
            utils.getBackgroundPictureBean().setIsUseBackgroundFile(true);
            utils.saveData();
            updatePreviewBackground();
        }
    };

	private View.OnClickListener onPixelPickerClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
			// 从文件路径启动像素拾取活动
			//String imagePath = "/storage/emulated/0/DCIM/Camera/sample.jpg";
			String imagePath = mfRecivedCropPicture.toString();
			Intent intent = new Intent(getApplicationContext(), PixelPickerActivity.class);
			intent.putExtra("imagePath", imagePath);
			startActivity(intent);
            //App.getWinBoLLActivityManager().startWinBoLLActivity(getActivity(), intent, PixelPickerActivity.class);
        }
    };

	private View.OnClickListener onCleanPixelClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
			BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(BackgroundPictureActivity.this);
			BackgroundPictureBean bean = utils.getBackgroundPictureBean();
			bean.setPixelColor(0);
			utils.saveData();
			setBackgroundColor();
        }
    };

    /**
     * 压缩图片并保存到接收文件
     */
    void compressQualityToRecivedPicture(Bitmap bitmap) {
        OutputStream outStream = null;
        try {
            mfRecivedPicture = getRecivedPictureFile(this);
            if (!mfRecivedPicture.exists()) {
                mfRecivedPicture.createNewFile();
            }

            FileOutputStream fos = new FileOutputStream(mfRecivedPicture);
            outStream = new BufferedOutputStream(fos);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outStream);
            outStream.flush();
        } catch (IOException e) {
            LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
            ToastUtils.show("图片压缩失败");
        } finally {
            if (outStream != null) {
                try {
                    outStream.close();
                } catch (IOException e) {
                    LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
                }
            }
            if (bitmap != null && !bitmap.isRecycled()) {
                bitmap.recycle();
            }
        }
    }

    /**
     * 启动图片裁剪活动
     * @param isCropFree 是否自由裁剪
     */
    public void startCropImageActivity(boolean isCropFree) {
        LogUtils.d(TAG, "startCropImageActivity");
        BackgroundPictureBean bean = mBackgroundPictureUtils.loadBackgroundPictureBean();
        mfRecivedPicture = getRecivedPictureFile(this);
        Uri uri = UriUtil.getUriForFile(this, mfRecivedPicture);
        LogUtils.d(TAG, "uri : " + uri.toString());

        if (mfTempCropPicture.exists()) {
            mfTempCropPicture.delete();
        }
        try {
            mfTempCropPicture.createNewFile();
        } catch (IOException e) {
            LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
            ToastUtils.show("剪裁临时文件创建失败");
            return;
        }

        Uri cropOutPutUri = Uri.fromFile(mfTempCropPicture);
        LogUtils.d(TAG, "mfTempCropPicture : " + mfTempCropPicture.getPath());

        Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(uri, "image/" + _mszCommonFileType);
        intent.putExtra("crop", "true");
        intent.putExtra("noFaceDetection", true);

        if (!isCropFree) {
            intent.putExtra("aspectX", bean.getBackgroundWidth());
            intent.putExtra("aspectY", bean.getBackgroundHeight());
        }

        intent.putExtra("return-data", true);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, cropOutPutUri);
        intent.putExtra("scale", true);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
        startActivityForResult(intent, REQUEST_CROP_IMAGE);
    }

    /**
     * 保存剪裁后的Bitmap（优化版）
     */
    private void saveCropBitmap(Bitmap bitmap) {
        if (bitmap == null) {
            ToastUtils.show("剪裁图片为空");
            return;
        }

        // 内存优化：大图片自动缩放
        Bitmap scaledBitmap = bitmap;
        if (bitmap.getByteCount() > 10 * 1024 * 1024) { // 超过10MB
            float scale = 1.0f;
            while (scaledBitmap.getByteCount() > 5 * 1024 * 1024) {
                scale -= 0.2f; // 每次缩小20%
                if (scale < 0.2f) break; // 最小缩放到20%
                scaledBitmap = scaleBitmap(scaledBitmap, scale);
            }
            if (scaledBitmap != bitmap) {
                bitmap.recycle(); // 回收原Bitmap
            }
        }

        // 优化：创建保存目录
        File backgroundDir = new File(mBackgroundPictureUtils.getBackgroundDir());
        if (!backgroundDir.exists()) {
            if (!backgroundDir.mkdirs()) {
                ToastUtils.show("无法创建保存目录");
                if (scaledBitmap != bitmap) scaledBitmap.recycle();
                return;
            }
        }

        File saveFile = new File(backgroundDir, getBackgroundFileName());

        // 优化：检查文件是否可写
        if (saveFile.exists() && !saveFile.canWrite()) {
            if (!saveFile.delete()) {
                ToastUtils.show("无法删除旧文件");
                if (scaledBitmap != bitmap) scaledBitmap.recycle();
                return;
            }
        }

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(saveFile);
            boolean success = scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, fos);
            fos.flush();
            if (success) {
                ToastUtils.show("保存成功");
                // 更新数据
                mBackgroundPictureUtils.getBackgroundPictureBean().setIsUseBackgroundFile(true);
                updatePreviewBackground();
            } else {
                ToastUtils.show("图片压缩保存失败");
            }
        } catch (FileNotFoundException e) {
            LogUtils.e(TAG, "文件未找到" + e);
            ToastUtils.show("保存失败：文件路径错误");
        } catch (IOException e) {
            LogUtils.e(TAG, "写入异常" + e);
            ToastUtils.show("保存失败：磁盘可能已满或路径错误");
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    LogUtils.e(TAG, "流关闭异常" + e);
                }
            }
            if (scaledBitmap != null && !scaledBitmap.isRecycled()) {
                scaledBitmap.recycle();
            }
        }
    }

    /**
     * 缩放Bitmap
     */
    private Bitmap scaleBitmap(Bitmap original, float scale) {
        if (original == null) {
            return null;
        }
        int width = (int) (original.getWidth() * scale);
        int height = (int) (original.getHeight() * scale);
        return Bitmap.createScaledBitmap(original, width, height, true);
    }

    /**
     * 分享图片
     */
    void sharePicture() {
        Uri uri = UriUtil.getUriForFile(this, mfRecivedPicture);
        Intent shareIntent = new Intent(Intent.ACTION_SEND);
        shareIntent.putExtra(Intent.EXTRA_STREAM, uri);
        shareIntent.setType("image/" + _mszCommonFileType);
        shareIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
        startActivity(Intent.createChooser(shareIntent, "Share Image"));
    }

    public static File getRecivedPictureFile(Context context) {
        BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(context);
        utils.loadBackgroundPictureBean();
        return new File(utils.getBackgroundDir(), _RecivedPictureFileName);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_SELECT_PICTURE && resultCode == RESULT_OK) {
            try {
                Uri selectedImage = data.getData();
                LogUtils.d(TAG, "Uri is : " + selectedImage.toString());
                File fSrcImage = new File(UriUtil.getFilePathFromUri(this, selectedImage));
                mfRecivedPicture = getRecivedPictureFile(this);
                if (FileUtils.copyFile(fSrcImage, mfRecivedPicture)) {
                    startCropImageActivity(false);
                } else {
                    ToastUtils.show("图片复制失败，请重试");
                }
            } catch (Exception e) {
                LogUtils.e(TAG, "选择图片异常" + e);
                ToastUtils.show("选择图片失败：" + e.getMessage());
            }
        } else if (requestCode == REQUEST_TAKE_PHOTO && resultCode == RESULT_OK) {
            LogUtils.d(TAG, "REQUEST_TAKE_PHOTO");
            Bundle extras = data.getExtras();
            if (extras != null) {
                Bitmap imageBitmap = (Bitmap) extras.get("data");
                if (imageBitmap != null) {
                    compressQualityToRecivedPicture(imageBitmap);
                    startCropImageActivity(false);
                } else {
                    ToastUtils.show("拍照图片为空");
                }
            } else {
                ToastUtils.show("拍照数据获取失败");
            }
        } else if (requestCode == REQUEST_CROP_IMAGE && resultCode == RESULT_OK) {
            LogUtils.d(TAG, "CROP_IMAGE_REQUEST_CODE");
            try {
                Bitmap cropBitmap = null;
                // 方案1：通过Intent获取剪裁后的Bitmap
                if (data != null && data.hasExtra("data")) {
                    cropBitmap = data.getParcelableExtra("data");
                } else if (mfTempCropPicture.exists()) {
                    cropBitmap = BitmapFactory.decodeFile(mfTempCropPicture.getPath());
                } else {
                    ToastUtils.show("剪裁文件不存在");
                    return;
                }

                if (cropBitmap != null) {
                    saveCropBitmap(cropBitmap);
                } else {
                    ToastUtils.show("获取剪裁图片失败");
                }
            } catch (OutOfMemoryError e) {
                LogUtils.e(TAG, "内存溢出" + e);
                ToastUtils.show("保存失败：内存不足，请尝试裁剪更小的图片");
            } catch (Exception e) {
                LogUtils.e(TAG, "剪裁保存异常" + e);
                ToastUtils.show("保存失败：" + e.getMessage());
            }/* finally {
			 // 安全删除临时文件
			 if (mfTempCropPicture.exists()) {
			 mfTempCropPicture.delete();
			 }
			 }*/
        } else if (resultCode != RESULT_OK) {
            LogUtils.d(TAG, "操作取消或失败，requestCode: " + requestCode);
            ToastUtils.show("操作已取消");
        }
    }

    /**
     * 检查类型是否为图片
     */
    private boolean isImageType(String type) {
        return type.startsWith("image/") || "image/jpeg".equals(type) || 
            "image/jpg".equals(type) || "image/png".equals(type) || 
            "image/webp".equals(type);
    }

    /**
     * 检查并申请存储权限
     */
    private boolean checkAndRequestStoragePermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(this, 
                                                  new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 
                                                  STORAGE_PERMISSION_REQUEST);
                return false;
            }
        }
        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == STORAGE_PERMISSION_REQUEST) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                ToastUtils.show("存储权限已获取");
            } else {
                ToastUtils.show("需要存储权限才能保存图片");
            }
        }
    }

	void setBackgroundColor() {
		BackgroundPictureUtils utils = BackgroundPictureUtils.getInstance(BackgroundPictureActivity.this);
		BackgroundPictureBean bean = utils.getBackgroundPictureBean();
		int nPixelColor = bean.getPixelColor();
		RelativeLayout mainLayout = findViewById(R.id.activitybackgroundpictureRelativeLayout1);
		mainLayout.setBackgroundColor(nPixelColor);
	}

	@Override
	protected void onResume() {
		super.onResume();
		setBackgroundColor();
	}
}

