package com.DeviceTest.helper;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.security.auth.PrivateCredentialPermission;

import android.R.integer;
import android.R.string;
import android.app.ActivityManager;
import android.bluetooth.BluetoothAdapter;
import android.content.Context;
import android.graphics.Camera;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.Parameters;
import android.hardware.Camera.Size;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Environment;
import android.os.RemoteException;
import android.os.StatFs;
//import android.os.IECService;
import android.os.ServiceManager;
import android.os.SystemProperties;
import android.text.format.Formatter;
import android.util.Log;

/*
 * TODO：获取系统相关信息
 * 
 * Data：2013-04-24
 */

public class SystemInfoUtil {
	private static final String TAG = "SystemInfoUtil";

	// 获取sdcard 的大小
	private static void getSdcardStorageSize() {
		String state = Environment.getExternalStorageState();
		if (Environment.MEDIA_MOUNTED.equals(state)) {
			File sdcardDir = Environment.getExternalStorageDirectory();
			StatFs sf = new StatFs(sdcardDir.getPath());
			long blockSize = sf.getBlockSize();
			long blockCount = sf.getBlockCount();
			long availCount = sf.getAvailableBlocks();
			Log.d("cghs", "block大小:" + blockSize + ",block数目:" + blockCount
					+ ",总大小:" + blockSize * blockCount / 1024 + "KB");
			Log.d("cghs", "可用的block数目：:" + availCount + ",剩余空间:" + availCount
					* blockSize / 1024 + "KB");
		}
	}

	// 获取系统分区的大小
	private static void getSystemStorageSize() {
		File root = Environment.getRootDirectory();
		StatFs sf = new StatFs(root.getPath());
		long blockSize = sf.getBlockSize();
		long blockCount = sf.getBlockCount();
		long availCount = sf.getAvailableBlocks();
		Log.d("cghs", "block大小:" + blockSize + ",block数目:" + blockCount
				+ ",总大小:" + blockSize * blockCount / 1024 + "KB");
		Log.d("cghs", "可用的block数目：:" + availCount + ",可用大小:" + availCount
				* blockSize / 1024 + "KB");
	}

	// 获得内存信息 方法1
	public static String GetMemInfo1(Context mContext) {
		long MEM_UNUSED;
		long MEM_TOTAL;
		// 得到ActivityManager
		ActivityManager am = (ActivityManager) mContext
				.getSystemService(Context.ACTIVITY_SERVICE);
		// 创建ActivityManager.MemoryInfo对象
		ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
		am.getMemoryInfo(mi);

		// 取得剩余的内存空间
		MEM_UNUSED = mi.availMem / (1024*1024);
		MEM_TOTAL = mi.totalMem / (1024*1024);
		Log.d("cghs", "MEN_UNUSER: " + MEM_UNUSED + " MEM_TOTAL:" + MEM_TOTAL);
		String memStr = MEM_TOTAL + " MB";
		return memStr;

	}

	// 获得内存信息 方法2
	public static void GetMemInfo2() {
		List<String> contents = new ArrayList<String>();
		long mTotal;
		// /proc/meminfo读出的内核信息进行解释
		String path = "/proc/meminfo";
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(path), 8);
			String line;
			if ((line = br.readLine()) != null) {
				contents.add(line);
			}

			if ((line = br.readLine()) != null) {
				contents.add(line);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

		String total = contents.get(0);
		String rest = contents.get(1);
		// beginIndex
		int begin = total.indexOf(':');
		// endIndex
		int end = total.indexOf('k');
		// 截取字符串信息

		total = total.substring(begin + 1, end).trim();
		mTotal = Integer.parseInt(total);
		Log.d("cghs", "mTotal: " + mTotal);
		Log.d("cghs", "" + rest);
	}

	// -------------------------CPU INFO-------------------------

	// 获取CPU名字
	public static String getCpuName() {
		try {
			FileReader fr = new FileReader("/proc/cpuinfo");
			BufferedReader br = new BufferedReader(fr);
			String text = br.readLine();
			String[] array = text.split(":\\s+", 2);
			for (int i = 0; i < array.length; i++) {
			}
			return array[1];
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public static String getCpuNameByProp() {
		String name = null;
		name = SystemProperties.get("ro.rk.cpu", "rk3188");
		return name;
	}

	// 获取CPU最大频率（单位KHZ）
	// "/system/bin/cat" 命令行
	// "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq" 存储最大频率的文件的路径
	public static String getMaxCpuFreq() {
		String result = "N/A";
		try {
			FileReader fr = new FileReader(
					"/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq");
			BufferedReader br = new BufferedReader(fr);
			String text = br.readLine();
			result = text.trim();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	// 获取CPU最小频率（单位KHZ）
	public static String getMinCpuFreq() {
		String result = "";
		ProcessBuilder cmd;
		try {
			String[] args = { "/system/bin/cat",
					"/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_min_freq" };
			cmd = new ProcessBuilder(args);
			Process process = cmd.start();
			InputStream in = process.getInputStream();
			byte[] re = new byte[24];
			while (in.read(re) != -1) {
				result = result + new String(re);
			}
			in.close();
		} catch (IOException ex) {
			ex.printStackTrace();
			result = "N/A";
		}
		return result.trim();
	}

	// 实时获取CPU当前频率（单位KHZ）
	public static String getCurCpuFreq() {
		String result = "N/A";
		try {
			FileReader fr = new FileReader(
					"/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq");
			BufferedReader br = new BufferedReader(fr);
			String text = br.readLine();
			result = text.trim();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	// 获取 cpu 核数
	public static int getNumCores() {
		// Private Class to display only CPU devices in the directory listing
		class CpuFilter implements FileFilter {
			@Override
			public boolean accept(File pathname) {
				// Check if filename is "cpu", followed by a single digit number
				if (Pattern.matches("cpu[0-9]", pathname.getName())) {
					return true;
				}
				return false;
			}
		}

		try {
			// Get directory containing CPU info
			File dir = new File("/sys/devices/system/cpu/");
			// Filter to only list the devices we care about
			File[] files = dir.listFiles(new CpuFilter());
			// Return the number of cores (virtual CPU devices)
			return files.length;
		} catch (Exception e) {
			e.printStackTrace();
			// Default to return 1 core
			return 1;
		}
	}

	/**
	 * 获取 HDD 大小
	 * 
	 */
	 /*
	public static String getHDDSize(Context context) {
		int trytime = 0;
		String flash_path = "/mnt/sdcard";
		while(!getSdCardState(flash_path).equals(Environment.MEDIA_MOUNTED)) {
			try {
				Thread.sleep(500);
			} catch (Exception e) {
				
			}
			trytime ++;
			if (trytime >= 8) {
				Log.e(TAG, "getHDDSize(): flash unmount");
				return "err!";
			}
		}
		
		
		StatFs stat = new StatFs(flash_path);
		long blockSize = stat.getBlockSize();
		long totalBlocks = stat.getBlockCount();
		long availableBlocks = stat.getAvailableBlocks();
		float size = (blockSize * totalBlocks)/(1024*1024);
		float sizeInGB = size / 1024;
		if (sizeInGB > 11.00f && sizeInGB < 20.00f) {
			return "16.00 GB";
		} else if (sizeInGB > 20.00f) {
			return "32.00 GB";
		}
		return Formatter.formatFileSize(context, blockSize * totalBlocks);

	}
	*/
	
	/**
	 * 获取当前路径下硬盘是否挂载。
	 */
	/*public static String getSdCardState(String path) {
        try {
        	IMountService mMntSvc = null;
            if (mMntSvc == null) {
                mMntSvc = IMountService.Stub.asInterface(ServiceManager
                                                         .getService("mount"));
            }
            return mMntSvc.getVolumeState(path);
        } catch (Exception rex) {
            return Environment.MEDIA_REMOVED;
        }

    }
*/
	/*
	 * 获取wifi MAC need permission: <uses-permission
	 * android:name="android.permission.ACCESS_WIFI_STATE"/> <uses-permission
	 * android:name="android.permission.INTERNET"/>
	 */
	public static String getLocalMacAddress(Context context) {
		WifiManager wifi = (WifiManager) context
				.getSystemService(Context.WIFI_SERVICE);
		if (!wifi.isWifiEnabled()) {
		//	wifi.setWifiEnabled(true);
		}
		WifiInfo info = wifi.getConnectionInfo();
		String mac =  info.getMacAddress();
		wifi.setWifiEnabled(false);
		return mac;

	}

	public static String getAndroidVersion() {
		return Build.VERSION.RELEASE;
	}

	/**
	 * 获取kernel 版本
	 */
	public static String getFormattedKernelVersion() {
		String procVersionStr;

		try {
			BufferedReader reader = new BufferedReader(new FileReader(
					"/proc/version"), 256);
			try {
				procVersionStr = reader.readLine();
			} finally {
				reader.close();
			}

			final String PROC_VERSION_REGEX = "\\w+\\s+" + /* ignore: Linux */
			"\\w+\\s+" + /* ignore: version */
			"([^\\s]+)\\s+" + /* group 1: 2.6.22-omap1 */
			"\\(([^\\s@]+(?:@[^\\s.]+)?)[^)]*\\)\\s+" + /*
														 * group 2:
														 * (xxxxxx@xxxxx
														 * .constant)
														 */
			"\\((?:[^(]*\\([^)]*\\))?[^)]*\\)\\s+" + /* ignore: (gcc ..) */
			"([^\\s]+)\\s+" + /* group 3: #26 */
			"(?:PREEMPT\\s+)?" + /* ignore: PREEMPT (optional) */
			"(.+)"; /* group 4: date */

			Pattern p = Pattern.compile(PROC_VERSION_REGEX);
			Matcher m = p.matcher(procVersionStr);

			if (!m.matches()) {

				return "Unavailable";
			} else if (m.groupCount() < 4) {

				return "Unavailable";
			} else {
				return (new StringBuilder(m.group(1)).append("\n")
						.append(m.group(2)).append(" ").append(m.group(3))
						.append("\n").append(m.group(4))).toString();
			}
		} catch (IOException e) {

			return "Unavailable";
		}
	}

	/**
	 * 获取product 名字
	 */
	public static String getProductName() {
		return Build.PRODUCT;
	}

/*	public static String getFormattedECVersion() {
		IECService ecService;
		byte[] vv = new byte[2];
		int ecVersion;
		try {
			ecService = IECService.Stub.asInterface(ServiceManager
					.getService("ECServiceinfo"));
			if (ecService == null) {
				Log.e(TAG, "Unable to create the ECService instance!");
				return "Unavailable";
			}

			ecVersion = ecService.getVersion();

			vv[0] = (byte) (ecVersion & 0x000000FF);
			vv[1] = (byte) ((ecVersion >> 8) & 0x000000FF);

			return String.format("%02x %02x", vv[1], vv[0]);

		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			Log.e(TAG,
					"IO Exception when getting ec version for Device Info screen",
					e);
			return "Unavailable";
		}
	}
*/
	public static String getCameraId() {
		String pidcmd = "/system/bin/cat /sys/bus/usb/devices/3-1/idProduct";
		String vidcmd = "/system/bin/cat /sys/bus/usb/devices/3-1/idVendor";
		String pid = runCmd(pidcmd);
		String vid = runCmd(vidcmd);
		return pid+"&"+vid;
	
	}

	public static String getWlanId(Context c) {
		int trytime = 0;
		WifiManager mWifiManager = (WifiManager) c.getSystemService(Context.WIFI_SERVICE);
	/*	mWifiManager.setWifiEnabled(true);
		while (!mWifiManager.isWifiEnabled()) {
			try {
				Thread.sleep(500);
				trytime ++;
				if (trytime >= 8) {
					Log.e(TAG, "getWlanId(): open wifi timeout!");
					mWifiManager.setWifiEnabled(false);
					return "err!";
				}
			} catch (Exception e) {
			}
		}*/
//		String id = runCmd("/system/bin/iwpriv wlan0 read 1,fc");
////		mWifiManager.setWifiEnabled(false);
//		if (id == null) return "err!";
//		String[] ids = id.split(":");
//		if (ids.length > 1) {
//			return ids[1];
//		}
//		return "err!";
		WifiInfo info = mWifiManager.getConnectionInfo();
		return info.getMacAddress();
		
	}

/*	  public static String getTouchpadId(){
	    	String touchpadId=null;	
	    	try {
	    	    IECService ecService;
		    	ecService=IECService.Stub.asInterface(ServiceManager.getService("ECServiceinfo"));
				if(ecService==null){
					Log.e(TAG,"Unable to create the ECService instance!");
					return "Unavailable";
				}
				int padid=ecService.DeviceCtrl(16,0);
		        if(padid==0)touchpadId="Elan";
		        else{
		        	if(padid==1)touchpadId="Synaptics";
		        	else touchpadId="Unknow";
		        }
	       }catch (RemoteException e) {
				// TODO Auto-generated catch block
	    	   Log.e(TAG,"IO Exception when getting touchpadId  ",e);  		
	    	   return "Unavailable";
			}
			return touchpadId;	
		}

	  public static String getBatteryCell(){
	    String batteryCell=null;
	    	try {
	    	    IECService ecService;
		    	ecService=IECService.Stub.asInterface(ServiceManager.getService("ECServiceinfo"));
				if(ecService==null){
					Log.e(TAG,"Unable to create the ECService instance!");
					return "Unavailable";
				}
				int batid=ecService.DeviceCtrl(17,0);
		        if(batid==0)batteryCell="Other";
		        else{
		        	if(batid==1)batteryCell="Simplo";
		        	else batteryCell="Unknow";
		        }
	       }catch (RemoteException e) {
				// TODO Auto-generated catch block
	    	   Log.e(TAG,"IO Exception when getting batteryCell  ",e);  		
	    	   return "Unavailable";
			}
			return batteryCell;
		}
	    
	   public static String getTouchpanelId(){
	        String touchpanelId=null;
	        try {
	     	    IECService ecService;
	 	    	ecService=IECService.Stub.asInterface(ServiceManager.getService("ECServiceinfo"));
	 			if(ecService==null){
	 				Log.e(TAG,"Unable to create the ECService instance!");
	 				return "Unavailable";
	 			}
	 			int padid=ecService.DeviceCtrl(18,0);
	 	        if(padid==0)touchpanelId="Ofilm";
	 	        else{
	 	        	if(padid==1)touchpanelId="Mutto";
	 	        	else touchpanelId="Unknow";
	 	        }
	        } catch (RemoteException e) {
	 			// TODO Auto-generated catch block
	     	   Log.e(TAG,"IO Exception when getting Touchpanel id ",e);  		
	     	   return "Unavailable";
	 		}
	 		return touchpanelId;	
	 	}
*/	
	public static String runCmd(String cmd) {
		Process process = null;
		InputStreamReader mISR;
        StringBuilder sBuilder = new StringBuilder();
        String temp;
		try {
			process = Runtime.getRuntime().exec(cmd);
			BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
//            while ((temp = reader.readLine()) != null) {
//            	Log.e("cghs", "temp:"+temp);
//            }
			temp = reader.readLine();
            process.destroy();
            reader.close();
			return temp;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	
	public static String getBuildNumber() {
	
		String  mBuildNum=null;
		String  aa=null;
                String  Build_number=null;
	        mBuildNum=Build.DISPLAY;
		
		int key=mBuildNum.indexOf("A10_S");	
	        if(key>0){
                        aa=mBuildNum.substring(key);
                        if(aa!=null&&aa.length()>=15)
                        	Build_number=mBuildNum.substring(key, key+15);
		}
           return Build_number;
	}
	
	//get BTMAC by mw
	public static String getBTMAC() {
		BluetoothAdapter mAdapter = BluetoothAdapter.getDefaultAdapter();
	//	mAdapter.enable();
		return mAdapter.getAddress();
	}
	
	//get EMMC by mw
	public static String getEMMC(Context c) {
		File dataPath = Environment.getDataDirectory();
        StatFs stat = new StatFs(dataPath.getPath());
        long blockSize = stat.getBlockSize();
        long availableBlocks = stat.getAvailableBlocks();
        return Formatter.formatFileSize(c, availableBlocks * blockSize);
	}
		
}