package com.sunvote.xpadapp.fragments;

import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import com.sunvote.xpadapp.MainActivity;
import com.sunvote.xpadapp.R;
import com.sunvote.xpadapp.base.BaseFragment;
import com.sunvote.xpadapp.utils.FileUtil;
import com.sunvote.xpadapp.utils.LogUtil;
import com.sunvote.xpadapp.utils.WifiConnector;
import com.sunvote.xpadapp.utils.WifiConnector.WifiCipherType;
import com.sunvote.xpadcomm.FileRecver;
import com.sunvote.xpadcomm.FileRecver.FileReciverInterface;

import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.TextView;
import android.widget.Toast;

public class DownloadFragment extends BaseFragment implements FileReciverInterface {
	private final String TAG = "DownloadFragment";
	private WifiManager wifiManager;
	private WifiConnector wac;

	private String serverIp = "127.0.0.1";
	private int serverPort = 15154;

	private String ssid = "";
	private String pwd = "";
	private int keypadId ;

	private boolean isConnectWifi;
	private FileRecver fileReciver = null;
	private TextView tv;

	private final int msgConnectError = 1;
	private final int msgOnDownload = 2;
	private final int msgDownloadOver = 3;
	private final int msgDownloadDataError = 4;
	private final int msgDownloadUserStop = 5;
	private final int msgOnUnzipError = 6;
	private final int msgGoBack= 7;

	private boolean isUiActive;
	private int downloadRetryCount ;

	public boolean isFinishDownload;

	private NetworkConnectChangedReceiver wifiReciver = new NetworkConnectChangedReceiver();

	public void setInfo(String wifiSsid, String wifiPassword, String ip, int port,int deviceId) {
		if (wifiSsid != null) {
			ssid = wifiSsid;
		}
		if (wifiPassword != null) {
			pwd = wifiPassword;
		}
		if (ip != null) {
			serverIp = ip;
		}
		if (port != 0) {
			serverPort = port;
		}
		keypadId = deviceId;
		isFinishDownload = false;
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
		Log.d(TAG, "onCreateView");
		View view = inflater.inflate(R.layout.fragment_download, container, false);
		view.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				;
			}
		});
		tv = (TextView) view.findViewById(R.id.download_title);
		downloadRetryCount = 0;
		tv.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// connectWifiThread.run();
				// connectWifi();
			}
		});

		return view;
	}

	@Override
	public void onResume() {
		super.onResume();
		isUiActive = true;
	}

	@Override
	public void onPause() {
		super.onPause();
		isUiActive = false;
	}

	@Override
	public void onActivityCreated(Bundle savedInstanceState) {

		super.onActivityCreated(savedInstanceState);
		wifiManager = (WifiManager) getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
		wac = new WifiConnector(wifiManager);

		List<WifiConfiguration> wlist = wifiManager.getConfiguredNetworks();
		if (wlist != null) {
			for (int i = 0; i < wlist.size(); i++) {
				WifiConfiguration wifiCfg = wlist.get(i);
				wifiManager.removeNetwork(wifiCfg.networkId);
			}
		}
		wifiManager.saveConfiguration();
		wlist = wifiManager.getConfiguredNetworks();
		if (wifiManager.isWifiEnabled()) {
			Log.d(TAG, "onActivityCreated  isWifiEnabled= true ");
			WifiInfo info = wifiManager.getConnectionInfo();
			String tmpSsid = info.getSSID();
			int netId = info.getNetworkId();
			Log.d(TAG, "connected:" + tmpSsid);

			disableWifi();
		} else {

		}

		setWifiListener();
		Log.d(TAG, "timer.schedule");
		timer = new Timer(false);
		MyTask tmtsk = new MyTask();
		timer.schedule(tmtsk, 200, 60000);
	}

	@Override
	public void onDestroy() {
		getActivity().unregisterReceiver(wifiReciver);
		Log.d(TAG, "unregisterReceiver(wifiReciver)");
		super.onDestroy();

	}

//	private Timer timerBack;
//	private class autoBackTask extends TimerTask {
//
//		@Override
//		public void run() {
//			Log.i(TAG, "autoBackTask........");
//			if(isUiActive){
//				Message message = new Message();
//				message.what = msgGoBack;
//				mHandler.sendMessage(message);
//			}
//			timerBack.cancel();
//		}
//	};

	private Handler mHandler = new Handler() {

		public void handleMessage(Message msg) {
			switch (msg.what) {
			case msgConnectError:
				cancelTimer();
				disableWifi();
				if(isUiActive) {
					tv.setText(getString(R.string.connect_server_fail));
				}
				break;
			case msgOnDownload:
				Log.d(TAG, getString(R.string.downloading) + msg.arg1 + "%");
				if(isUiActive) {
					int percent = msg.arg1;

					tv.setText(getString(R.string.downloading) + percent + "%");
					if(percent == 100){
						tv.setText(getString(R.string.download_over_unzip));
					}
				}
				break;
			case msgDownloadOver:
				try {
					Log.d(TAG, "on msgDownloadOver");
					if(isUiActive) {
						tv.setText(getString(R.string.download_over));
					}
					isFinishDownload = true;
					disableWifi();
					if(mMainActivity.dbm != null){
						mMainActivity.dbm.closeDB();
						mMainActivity.dbm = null;
					}
//					timerBack = new Timer(true);
//					autoBackTask backTsk = new autoBackTask();
//					timerBack.schedule(backTsk, 30000, 30000);
				} catch (Exception e) {
					e.printStackTrace();
				}

				break;
				case msgDownloadDataError:
					if(isUiActive) {
						if(++downloadRetryCount >= 3){//重试 n 次
							tv.setText(getString(R.string.download_fail));
							break;
						}
						cancelTimer();
						disableWifi();
						tv.setText(getString(R.string.download_retry));
						timer = new Timer(true);
						MyTask tmtsk = new MyTask();
						timer.schedule(tmtsk, 1000, 30000);
					}
					break;
				case msgOnUnzipError:
					Log.d(TAG, "handleMessage: msgOnUnzipError");
					tv.setText(getString(R.string.unzip_error));
					Toast.makeText(mMainActivity,getString(R.string.unzip_error),Toast.LENGTH_LONG).show();
					isFinishDownload = true;
					disableWifi();
					break;
				case msgDownloadUserStop:
					cancelTimer();
					disableWifi();

					break;
				case msgGoBack:
					goBack();
			}

			super.handleMessage(msg);
		};
	};

	private void setWifiListener() {
		IntentFilter intentFilter = new IntentFilter();
		intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
		getActivity().registerReceiver(wifiReciver, intentFilter);

	}

	private Timer timer;
	private class MyTask extends TimerTask {

		@Override
		public void run() {
			Log.i(TAG, "TimerTask........");
			LogUtil.d(TAG,"TimerTask");
			if (isConnectWifi) {
				Log.d(TAG, "tmtsk  isConnectWifi:true,  timer cancel ");
				LogUtil.d(TAG,"tmtsk  isConnectWifi:true,  timer cancel");
				cancelTimer();
			} else {
				Log.d(TAG, "tmtsk  isConnectWifi:false");
				Log.d(TAG, "try connect wifi");
				LogUtil.d(TAG,"try connect wifi");
				if (wifiManager.isWifiEnabled()) {
					disableWifi();
				}

				wac.connect(ssid, pwd,
						pwd.equals("") ? WifiCipherType.WIFICIPHER_NOPASS : WifiCipherType.WIFICIPHER_WPA);
			}

		}
	};

	private void cancelTimer() {
		LogUtil.d(TAG,"cancelTimer");
		if (timer != null) {
			timer.cancel();
			timer.purge();
			timer = null;
		}
	}

	private void disableWifi() {
		try {
			LogUtil.d(TAG, "disconnect & removeNetwork current!");
			WifiInfo info = wifiManager.getConnectionInfo();
			String tmpSsid = info.getSSID();
			int netId = info.getNetworkId();
			if (info != null) {
				Log.d(TAG, "disconnect & removeNetwork current!");
				wifiManager.disableNetwork(netId);
				wifiManager.disconnect();
				wifiManager.removeNetwork(netId);
			}

			Log.d(TAG, "remove all");
			isConnectWifi = false;
			List<WifiConfiguration> wlist = wifiManager.getConfiguredNetworks();
			if (wlist != null) {
				for (int i = 0; i < wlist.size(); i++) {
					WifiConfiguration wifiCfg = wlist.get(i);
					Log.d(TAG, "removeNetwork:" + wifiCfg.SSID);
					wifiManager.removeNetwork(wifiCfg.networkId);
				}
			}
			wifiManager.saveConfiguration();
			LogUtil.d(TAG, "disableWifi");
			wac.disableWifi();

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void forceStopDownload(){
		LogUtil.i(TAG, "forceStopDownload: ");
		if(fileReciver!=null) {
			fileReciver.cleanDownloadFiles();
		}
	}

	public void getMeetingFilesFromServer() {
		LogUtil.d(TAG, "getMeetingFilesFromServer");
		fileReciver = new FileRecver(DownloadFragment.this, serverIp, serverPort);

		//fileReciver.tryGetMeetingFiles(keypadId);//tcp
		fileReciver.tryGetMeetingFileInfo(keypadId);//udp
	}

	public class NetworkConnectChangedReceiver extends BroadcastReceiver {
		@Override
		public void onReceive(Context context, Intent intent) {

			ConnectivityManager connectMgr = (ConnectivityManager) getActivity().getSystemService("connectivity");
		//	NetworkInfo mobNetInfo = connectMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
			NetworkInfo wifiNetInfo = connectMgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

			if (wifiNetInfo.isConnected()) {
				Log.i(TAG, "wifi connected");

				WifiInfo info = wifiManager.getConnectionInfo();
				String tmpSsid = info.getSSID();
				int netId = info.getNetworkId();
				Log.d(TAG, "connected:" + tmpSsid);

				isConnectWifi = true;
				cancelTimer();
				connectServer();
			} else {
				Log.d(TAG, "not connect");
			}
		}
	}

	private void connectServer() {
		if(isUiActive) {
			tv.setText(getString(R.string.connect_server_ing));
		}
		LogUtil.d(TAG, getString(R.string.connect_server_ing));
		new Thread("socketThread") {
			public void run() {
				try {
					Thread.sleep(500);
					getMeetingFilesFromServer();
				} catch (InterruptedException e) {
				}
			}
		}.start();
	}

	@Override
	public void onConnectServerError() {
		Message message = new Message();
		message.what = msgConnectError;
		mHandler.sendMessage(message);
	}

	private class DownloadInfo {
		public long percent;
	}

	@Override
	public void onDownload(long percent) {
		Message message = new Message();
		message.what = msgOnDownload;
		message.arg1 = (int) percent;
		mHandler.sendMessage(message);

	}

	@Override
	public void onDownloadSuccess() {
		Message message = new Message();
		message.what = msgDownloadOver;
		mHandler.sendMessage(message);
	}

	@Override
	public void stopDownload() {
		Log.i(TAG, "stopDownload...");
		cancelTimer();
		disableWifi();
	}

	@Override
	public void onDownloadDataError() {
		Log.i(TAG, "onDownloadDataError...");
		LogUtil.d(TAG,"onDownloadDataError");


		Message message = new Message();
		message.what = msgDownloadDataError;
		mHandler.sendMessage(message);
	}

	@Override
	public void onDownloadUserStop() {
		Log.i(TAG, "onDownloadUserStop...");
		LogUtil.d(TAG,"onDownloadUserStop");

		Message message = new Message();
		message.what = msgDownloadUserStop;
		mHandler.sendMessage(message);
	}

	@Override
	public void onUnzipError() {

		LogUtil.d(TAG,"onUnzipError");

		Message message = new Message();
		message.what = msgOnUnzipError;
		mHandler.sendMessage(message);
	}

	private void goBack() {
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.setCustomAnimations(android.R.animator.fade_in, android.R.animator.fade_out);
		//tx.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
		tx.remove(DownloadFragment.this);
		tx.commit();

	}



}