package com.example.dataextraction;


import android.Manifest;
import android.accounts.Account;
import android.accounts.AccountManager;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.AppOpsManager;
import android.app.usage.NetworkStats;
import android.app.usage.NetworkStatsManager;
import android.app.usage.UsageStats;
import android.app.usage.UsageStatsManager;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.net.ConnectivityManager;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.RouteInfo;
import android.net.Uri;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.provider.CalendarContract;
import android.provider.CallLog;
import android.provider.ContactsContract;
import android.provider.MediaStore;
import android.provider.Telephony;
import android.provider.UserDictionary;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;


import com.google.firebase.storage.FirebaseStorage;
import com.google.firebase.storage.StorageReference;
import com.google.gson.JsonObject;

import org.json.JSONException;
import org.json.JSONObject;
import org.w3c.dom.Text;

import io.socket.client.IO;
import io.socket.client.Socket;

import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;

public class LoadingActivity extends Activity {

    private Socket socket;
    public ProgressBar bar;
    TextView progressText;
    TextView dataListText;
    DBHelper dbHelper;

    String[] permission_list = {
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.READ_CALENDAR,
            Manifest.permission.ACCESS_NETWORK_STATE,
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.READ_PHONE_STATE,
            Manifest.permission.GET_ACCOUNTS,
            Manifest.permission.READ_CONTACTS,
            Manifest.permission.READ_CALL_LOG,
            Manifest.permission.READ_PHONE_NUMBERS,
            Manifest.permission.READ_CONTACTS,
            Manifest.permission.READ_CALL_LOG,
            Manifest.permission.READ_SMS,
            Manifest.permission.ACCESS_WIFI_STATE
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_loading);
        bar = (ProgressBar) findViewById(R.id.simpleProgressBar);
        progressText = (TextView) findViewById(R.id.textView);
        dataListText = (TextView) findViewById(R.id.textView2);
    }

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

        AppOpsManager appOps = (AppOpsManager) getSystemService(Context.APP_OPS_SERVICE);
        int mode = appOps.checkOpNoThrow(AppOpsManager.OPSTR_GET_USAGE_STATS, android.os.Process.myUid(), getPackageName());
        boolean granted = (mode == AppOpsManager.MODE_ALLOWED);

        if (granted == false)
        {
            Intent intent = new Intent(android.provider.Settings.ACTION_USAGE_ACCESS_SETTINGS);
            startActivity(intent);
        }
        else {
            if(checkPermission()) {
//                try {
//                    socket = IO.socket("http://172.30.1.23:3000/");
//                    socket.connect();
//                    Log.i("SOCKET", "Connected");
//
//                }catch(Exception e){
//                    e.printStackTrace();
//                    Log.i("SOCKET", "Not Connected");
//                }
                BackThread thread = new BackThread();
                thread.setDaemon(true);
                thread.start();
                bar.setMax(140);

            }
        }
    }

    public boolean checkPermission(){
        //현재 안드로이드 버전이 6.0미만이면 메서드를 종료한다.
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
            return true;

        LinkedList<String> requestPerms = new LinkedList<>();
        for(String permission : permission_list){
            //권한 허용 여부를 확인한다.
            int chk = checkCallingOrSelfPermission(permission);

            if(chk == PackageManager.PERMISSION_DENIED){
                //권한 허용을여부를 확인하는 창을 띄운다
                requestPerms.add(permission);
            }
        }

        if(requestPerms.isEmpty())
            return true;

        requestPermissions(requestPerms.toArray(new String[0]),0);
        return false;
    }

    public void makeFile(StringBuffer output, String filename) {
        try {
        String response = output.toString();
        Log.i("MYLOG", response);

        String foldername = "/mnt/sdcard/TempTEMP";
        Log.i("MYLOG", foldername);
        File dir = new File (foldername);
        //디렉토리 폴더가 없으면 생성함
        if(!dir.exists()){
            dir.mkdir();
        }
        //파일 output stream 생성
        FileOutputStream fos = new FileOutputStream(foldername+"/"+filename, true);
        //파일쓰기
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fos));
        writer.write(response);
        writer.flush();

        writer.close();
        fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void copyFile(String inputPath, String inputFile, String outputPath) {

        InputStream in = null;
        OutputStream out = null;
        try {

            //create output directory if it doesn't exist
            File dir = new File (outputPath);
            if (!dir.exists())
            {
                dir.mkdirs();
            }

            in = new FileInputStream(inputPath + inputFile);
            out = new FileOutputStream(outputPath + inputFile);

            byte[] buffer = new byte[1024];
            int read;
            while ((read = in.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
            in.close();
            in = null;

            // write the output file (You have now copied the file)
            out.flush();
            out.close();
            out = null;

        }  catch (FileNotFoundException fnfe1) {
            Log.e("tag", fnfe1.getMessage());
        }
        catch (Exception e) {
            Log.e("tag", e.getMessage());
        }

    }

    public void makeTXT(){
        try {
            StringBuffer output = new StringBuffer();
            StringBuffer output2 = new StringBuffer();
            StringBuffer output3 = new StringBuffer();

            Process uptime = Runtime.getRuntime().exec(new String[]{"uptime"}); // uptime
            uptime.waitFor();
            BufferedReader reader = new BufferedReader(new InputStreamReader(uptime.getInputStream()));
            String line = "";
            while((line = reader.readLine()) != null){
                output.append(line + "\n");
            }
            makeFile(output, "uptime.txt");

            Process df = Runtime.getRuntime().exec(new String[]{"df"}); // file system get --> USB 꽂힌 것 알아낼 수 있을듯..?
            df.waitFor();
            BufferedReader reader2 = new BufferedReader(new InputStreamReader(df.getInputStream()));
            String line2 = "";
            while((line2 = reader2.readLine()) != null){
                output2.append(line2 + "\n");
            }
            makeFile(output2, "df.txt");

            Process netstat = Runtime.getRuntime().exec(new String[]{"netstat"}); // network stat
            netstat.waitFor();
            BufferedReader reader3 = new BufferedReader(new InputStreamReader(netstat.getInputStream()));
            String line3 = "";
            while((line3 = reader3.readLine()) != null){
                output3.append(line3 + "\n");
            }
            makeFile(output3, "netstat.txt");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    class BackThread extends Thread {
        @Override
        public void run() {
            makeTXT();

            dbHelper = new DBHelper(getApplicationContext());
            dbHelper.open();

            getPhoto();
            //alert("alert","photo");
            Log.i("MYLOG", "DB HY Part:1/14");
            handler.sendEmptyMessage(10);

            getVideo();
            //alert("alert","video");
            Log.i("MYLOG", "DB HY Part:2/14");
            handler.sendEmptyMessage(20);
            getAudio();
            //alert("alert","audio");
            Log.i("MYLOG", "DB HY Part:3/14");
            handler.sendEmptyMessage(30);

            getCalendarInfo();
            //alert("alert","calendar");
            Log.i("MYLOG", "DB HY Part:4/14");
            handler.sendEmptyMessage(40);

            getNetworkInfo();
            //alert("alert","network");
            Log.i("MYLOG", "DB HY Part:5/14");
            handler.sendEmptyMessage(50);

            getCallLog();
            //alert("alert","calllog");
            Log.i("MYLOG", "DB YM Part:6/14");
            handler.sendEmptyMessage(60);

            getContact();
            //alert("alert","contact");
            Log.i("MYLOG", "DB YM Part:7/14");
            handler.sendEmptyMessage(70);

            getSMSMessage();
            //alert("alert","sms");
            Log.i("MYLOG", "DB YM Part:8/14");
            handler.sendEmptyMessage(80);

            getWIFI();
            //alert("alert","wifi");
            Log.i("MYLOG", "DB YM Part:9/14");
            handler.sendEmptyMessage(90);

            getPhoneInfo();
            //alert("alert","phoneinfo");
            Log.i("MYLOG", "DB YY Part:10/14");
            handler.sendEmptyMessage(100);

            getAccountInfo();
            //alert("alert","accountinfo");
            Log.i("MYLOG", "DB YY Part:11/14");
            handler.sendEmptyMessage(110);

            getAppInfo();
            //alert("alert","appinfo");
            Log.i("MYLOG", "DB YY Part:12/14");
            handler.sendEmptyMessage(120);

            getUsageStats();
            //alert("alert","usagestats");
            Log.i("MYLOG", "DB YY Part:13/14");
            handler.sendEmptyMessage(130);

            getDocument();
            Log.i("MYLOG", "DB YY Part:14/14");
            handler.sendEmptyMessage(140);

            dbHelper.close();

            copyFile("/data/data/com.example.dataextraction/databases/", "InnerDatabase.db", "/sdcard/TempTEMP/");
            copyFile("/data/data/com.example.dataextraction/databases/", "networkDatabase.db", "/sdcard/TempTEMP/");
            goMainActivity();

            try {
                Thread.sleep(1000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            finish();
            //alert("end", "end");

        }

        Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                if(msg.what != 0){   // Message id 가 0 이면
                    bar.setProgress(msg.what); // 메인스레드의 UI 내용 변경
                    if(msg.what == 10){
                        dataListText.append("\n사진 데이터 추출 완료\n");
                    }
                    else if(msg.what == 20){
                        dataListText.append("\n비디오 데이터 추출 완료\n");
                    }
                    else if(msg.what == 30){
                        dataListText.append("\n오디오 데이터 추출 완료\n");
                    }
                    else if(msg.what == 40){
                        dataListText.append("\n캘린더 데이터 추출 완료\n");
                    }
                    else if(msg.what == 50){
                        dataListText.append("\n네트워크 데이터 추출 완료\n");
                    }
                    else if(msg.what == 60){
                        dataListText.append("\n통화 데이터 추출 완료\n");
                    }
                    else if(msg.what == 70){
                        dataListText.append("\n연락처 데이터 추출 완료\n");
                    }
                    else if(msg.what == 80){
                        dataListText.append("\n문자 데이터 추출 완료\n");
                    }
                    else if(msg.what == 90){
                        dataListText.append("\n와이파이 데이터 추출 완료\n");
                    }
                    else if(msg.what == 100){
                        dataListText.append("\n스마트폰 정보 데이터 추출 완료\n");
                    }
                    else if(msg.what == 110){
                        dataListText.append("\n계정 데이터 추출 완료\n");
                    }
                    else if(msg.what == 120){
                        dataListText.append("\n앱 정보 데이터 추출 완료\n");
                    }
                    else if(msg.what == 130){
                        dataListText.append("\n사용량 데이터 추출 완료\n");
                    }
                    else if(msg.what == 140){
                        dataListText.append("\n문서 데이터 추출 완료\n");
                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        progressText.setText("모든 데이터 추출 완료 > 내부 저장소의 TempTEMP 폴더를 USB로 이동시키세요.\n");
                    }

                }
            }
        };
    }

    public void goMainActivity() {
        startActivity(new Intent(LoadingActivity.this, MainActivity.class));
    }

    public void getDocument() {

        String[] projection = {
                MediaStore.Files.FileColumns._ID,
                MediaStore.Files.FileColumns.MIME_TYPE,
                MediaStore.Files.FileColumns.DATE_ADDED,
                MediaStore.Files.FileColumns.DATE_MODIFIED,
                MediaStore.Files.FileColumns.DISPLAY_NAME,
                MediaStore.Files.FileColumns.TITLE,
                MediaStore.Files.FileColumns.SIZE,
                MediaStore.Files.FileColumns.DATA
        };

        String mimeType = "application/pdf";

        String whereClause = MediaStore.Files.FileColumns.MIME_TYPE + " IN ('" + mimeType + "')"
                + " OR " + MediaStore.Files.FileColumns.MIME_TYPE + " LIKE 'application/vnd%'";
        String orderBy = MediaStore.Files.FileColumns.SIZE + " DESC";
        Cursor cursor = getContentResolver().query(MediaStore.Files.getContentUri("external"),
                projection,
                whereClause,
                null,
                orderBy);

        int idCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID);
        int mimeCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.MIME_TYPE);
        int addedCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATE_ADDED);
        int modifiedCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATE_MODIFIED);
        int nameCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DISPLAY_NAME);
        int titleCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.TITLE);
        int sizeCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.SIZE);
        int dataCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATA);

        if (cursor.moveToFirst()) {
            do {
                //Uri fileUri = Uri.withAppendedPath(MediaStore.Files.getContentUri("external"), cursor.getString(idCol));
                String mime = cursor.getString(mimeCol);
                long dateAdded = cursor.getLong(addedCol);
                long dateModified = cursor.getLong(modifiedCol);
                String name = cursor.getString(nameCol);
                String title = cursor.getString(titleCol);
                long size = cursor.getLong(sizeCol);
                String path = cursor.getString(dataCol);

                Log.i("documents", mime + ", " + dateAdded + ", " + dateModified + ", " + name + ", " + title + ", " + size + ", " + path);
                dbHelper.addDocumentInfo(cursor.getString(nameCol), cursor.getString(titleCol), cursor.getLong(addedCol)
                        , cursor.getLong(modifiedCol), cursor.getString(mimeCol), cursor.getString(dataCol),String.valueOf(cursor.getLong(sizeCol)));
            } while (cursor.moveToNext());
        }
    }

    public void getPhoto() {
        Uri uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;

        String[] projection = new String[]{
                MediaStore.Images.Media.TITLE,
                MediaStore.Images.Media._ID,
                MediaStore.Images.Media.DATE_ADDED,
                MediaStore.Images.Media.DISPLAY_NAME,
                MediaStore.Images.Media.MIME_TYPE,
                MediaStore.Images.Media.DATA,
                MediaStore.Images.Media.LATITUDE,
                MediaStore.Images.Media.LONGITUDE
        };
        Cursor cursor = getContentResolver().query(uri, projection, null, null, null);


        while (cursor.moveToNext()) {
            photoItem photo = new photoItem();
            photo.setTitle(cursor.getString(0));
            photo.setId(cursor.getInt(1));
            photo.setDate(cursor.getString(2));
            photo.setDisplayName(cursor.getString(3));
            photo.setType(cursor.getString(4));
            photo.setPath(cursor.getString(5));
            photo.setLatitude(cursor.getString(6));
            photo.setLongitude(cursor.getString(7));


            File f = new File(cursor.getString(5));
            long size = f.length();

            dbHelper.insertPColumn(photo.getTitle(), photo.getId(), photo.getDate()
                    , photo.getDisplayName(), photo.getType(), photo.getPath()
                    , photo.getLatitude(), photo.getLongitude(),String.valueOf(size));
        }

    }

    public void getVideo() {
        Uri uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;

        String[] projection = new String[]{
                MediaStore.Video.Media.ALBUM,
                MediaStore.Video.Media.ARTIST,
                MediaStore.Video.Media.BOOKMARK,
                MediaStore.Video.Media.CATEGORY,
                MediaStore.Video.Media.DESCRIPTION,
                MediaStore.Video.Media.LANGUAGE,
                MediaStore.Video.Media.LATITUDE,
                MediaStore.Video.Media.LONGITUDE,
                MediaStore.Video.Media.RESOLUTION,
                MediaStore.Video.Media.DATA,
                MediaStore.Video.Media.TAGS,
                MediaStore.Video.Media.DATE_ADDED,
                MediaStore.Video.Media.DISPLAY_NAME,
                MediaStore.Video.Media.MIME_TYPE,
                MediaStore.Video.Media.TITLE,
        };

        Cursor cursor = getContentResolver().query(uri, projection, null, null, null);

        while (cursor.moveToNext()) {
            videoItem video = new videoItem();

            video.setAlbum(cursor.getString(0));
            video.setArtist(cursor.getString(1));
            video.setBookmark(cursor.getString(2));
            video.setCategory(cursor.getString(3));
            video.setDescription(cursor.getString(4));
            video.setLanguage(cursor.getString(5));
            video.setLatitude(cursor.getString(6));
            video.setLongitude(cursor.getString(7));
            video.setResolution(cursor.getString(8));
            video.setPath(cursor.getString(9));
            video.setTags(cursor.getString(10));
            video.setDate_added(cursor.getString(11));
            video.setDisplay_Name(cursor.getString(12));
            video.setMIME_type(cursor.getString(13));
            video.setTitle(cursor.getString(14));

            File f = new File(cursor.getString(9));
            long size = f.length();

            dbHelper.insertVColumn(video.getTitle(), video.getDate_added(), video.getDisplay_Name()
                    , video.getMIME_type(), video.getPath(), video.getLatitude(), video.getLongitude()
                    , video.getAlbum(), video.getArtist(), video.getBookmark(), video.getCategory()
                    , video.getDescription(), video.getLanguage(), video.getResolution(), video.getTags(), String.valueOf(size));
        }
    }

    public void getAudio() {
        Uri uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;

        String[] projection = new String[]{
                MediaStore.Audio.Media.ALBUM,
                MediaStore.Audio.Media.ARTIST,
                MediaStore.Audio.Media.COMPOSER,
                MediaStore.Audio.Media.YEAR,
                MediaStore.Audio.Media.DATA,
                MediaStore.Audio.Media.DATE_ADDED,
                MediaStore.Audio.Media.MIME_TYPE,
                MediaStore.Audio.Media.SIZE,
                MediaStore.Audio.Media.TITLE,
        };

        Cursor cursor = getContentResolver().query(uri, projection, null, null, null);

        while (cursor.moveToNext()) {
            audioItem audio = new audioItem();
            audio.setAlbum(cursor.getString(0));
            audio.setArtist(cursor.getString(1));
            audio.setComposer(cursor.getString(2));
            audio.setYear(cursor.getString(3));
            audio.setPath(cursor.getString(4));
            audio.setDate_added(cursor.getString(5));
            audio.setMIME_TYPE(cursor.getString(6));
            audio.setSize(cursor.getString(7));
            audio.setTitle(cursor.getString(8));

            dbHelper.insertAColumn(audio.getTitle(), audio.getDate_added(), audio.getMIME_TYPE()
                    , audio.getPath(), audio.getAlbum(), audio.getArtist(), audio.getComposer()
                    , audio.getYear(), audio.getSize());
        }
    }

    private void getCalendarInfo() {
        ArrayList<calendarItem> calendarList = new ArrayList<>();

        Cursor cur = null;
        ContentResolver cr = getContentResolver();
        Uri uri = CalendarContract.Calendars.CONTENT_URI;

        if (checkSelfPermission(Manifest.permission.READ_CALENDAR) != PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(getApplicationContext(), "권한문제", Toast.LENGTH_LONG).show();
            return;
        }

        String[] event_projection = new String[]{
                CalendarContract.Calendars._ID,                           // 0
                CalendarContract.Calendars.ACCOUNT_NAME,                  // 1
                CalendarContract.Calendars.CALENDAR_DISPLAY_NAME,         // 2
                CalendarContract.Calendars.OWNER_ACCOUNT                  // 3
        };

        cur = cr.query(uri, event_projection, null, null, null);

        // Use the cursor to step through the returned records
        while (cur.moveToNext()) {

            long calID = 0;
            String displayName = null;
            String accountName = null;
            String ownerName = null;

            // Get the field values
            calID = cur.getLong(0);
            displayName = cur.getString(1);
            accountName = cur.getString(2);
            ownerName = cur.getString(3);

            Cursor cure = null;
            ContentResolver cre = getContentResolver();
            Uri urie = CalendarContract.Events.CONTENT_URI;

            String[] event_projection2 = new String[]{
                    CalendarContract.Events.CALENDAR_ID,                    //0
                    CalendarContract.Events.TITLE,                          // 2
                    CalendarContract.Events.EVENT_LOCATION,                 // 3
                    CalendarContract.Events.DESCRIPTION,                    // 4
                    CalendarContract.Events.DTSTART,                        // 5
                    CalendarContract.Events.DTEND,                          // 6
                    CalendarContract.Events.DURATION,                       // 9
                    CalendarContract.Events.ALL_DAY,                        // 10
                    CalendarContract.Events.RRULE,                          // 11
                    CalendarContract.Events.RDATE                           // 12
            };

            cure = cre.query(urie, event_projection2, null, null, null);
            while (cure.moveToNext()) {
                String calid = null;
                String title = null;
                String loc = null;
                String desc = null;
                long dtstart = 0;
                long dtend = 0;
                String duration = null;
                String all_day = null;
                String rrule = null;
                String rdate = null;

                calid = cure.getString(0);
                title = cure.getString(1);
                loc = cure.getString(2);
                desc = cure.getString(3);
                dtstart = cure.getLong(4);
                dtend = cure.getLong(5);
                duration = cure.getString(6);
                all_day = cure.getString(7);
                rrule = cure.getString(8);
                rdate = cure.getString(9);

                DateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date start = new Date(dtstart);
                Date end = new Date(dtend);

                //save
                if (calID == Integer.parseInt(calid)) {
                    calendarItem calendar = new calendarItem();

                    calendar.setCalID(Long.toString(calID));
                    calendar.setDisplayName(displayName);
                    calendar.setAccountName(accountName);
                    calendar.setOwnerName(ownerName);
                    calendar.setTitle(title);
                    calendar.setLoc(loc);
                    calendar.setDesc(desc);
                    calendar.setDtstart(timeFormat.format(start));
                    calendar.setDtend(timeFormat.format(end));
                    calendar.setDuration(duration);
                    calendar.setAllday(all_day);
                    calendar.setRrule(rrule);
                    calendar.setRdate(rdate);

                    dbHelper.insertCColumn(calendar.getTitle(), calendar.getCalID(), calendar.getLoc()
                            , calendar.getDesc(), calendar.getDtstart(), calendar.getDtend(), calendar.getDuration()
                            , calendar.getAllday(), calendar.getDisplayName(), calendar.getAccountName()
                            , calendar.getOwnerName(), calendar.getRrule(), calendar.getRdate());
                }
            }
        }

    }

    public void getNetworkInfo(){
        ConnectivityManager connectivityManager;
        LinkProperties linkProperties;
        connectivityManager = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
        Network[] networkList = connectivityManager.getAllNetworks();
        networkDBHelper dbNHelper = new networkDBHelper(getApplicationContext());
        dbNHelper.open();
        dbNHelper.deleteAllRows();
        for(Network network : networkList){
            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
            if(capabilities != null){
                if(capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)){
                    linkProperties = connectivityManager.getLinkProperties(network);
                    String domain = linkProperties.getDomains();
                    String interfacrName = linkProperties.getInterfaceName();
                    //String DnsServerName = linkProperties.getPrivateDnsServerName();
                    dbNHelper.insertColumn0(network.toString(), domain, interfacrName);
                    List<InetAddress> inetAddresses = linkProperties.getDnsServers();
                    for(InetAddress address : inetAddresses){
                        dbNHelper.insertColumn1(network.toString(), address.getHostAddress());
                    }
                    List<LinkAddress> linkAddresses = linkProperties.getLinkAddresses();
                    for(LinkAddress address : linkAddresses) {
                        dbNHelper.insertColumn2(network.toString(), address.getAddress().getHostAddress(), address.getPrefixLength());
                    }
                    List<RouteInfo> routeInfos = linkProperties.getRoutes();
                    for(RouteInfo routeinfo : routeInfos){
                        dbNHelper.insertColumn3(network.toString(), routeinfo.getDestination().toString()
                                , routeinfo.getDestination().getPrefixLength(), routeinfo.getGateway().toString()
                                ,routeinfo.getInterface());
                    }
                }
            }
        }
        dbNHelper.close();
    }

    public void getPhoneInfo(){
        TelephonyManager tm = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
        if (checkSelfPermission(Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(getApplicationContext(), "권한문제", Toast.LENGTH_LONG).show();
        }

        String adid = "";
//        try {
//            MainActivity.GoogleAppIdTask asyncTask = new MainActivity.GoogleAppIdTask();
//            adid = asyncTask.execute().get();
//        }catch(Exception e){
//            e.printStackTrace();
//        }

        dbHelper.addPhoneInfo(tm.getPhoneType(), tm.getDeviceSoftwareVersion(),
                tm.getLine1Number(), tm.getSubscriberId(), adid, tm.getCallState(),
                tm.getDataState(),tm.getNetworkType(),tm.getNetworkCountryIso(),
                tm.getSimCountryIso(),tm.getNetworkOperator(),tm.getSimOperator(),
                tm.getNetworkOperatorName(),tm.getSimOperatorName() ,tm.getSimSerialNumber(),
                tm.getSimState(),tm.isNetworkRoaming());


    }

    public void getAccountInfo(){

        AccountManager am = AccountManager.get(this);
        Account[] accounts = am.getAccounts();

        for(Account account : accounts) {
            dbHelper.addAccountInfo(account.name, account.type);
        }
    }

    public void getAppInfo() {

        PackageManager pm = getPackageManager();
        List<PackageInfo> packages = pm.getInstalledPackages(PackageManager.GET_META_DATA);
        ApplicationInfo applicationInfo;
        NetworkStatsManager networkStatsManager = (NetworkStatsManager) getSystemService(Context.NETWORK_STATS_SERVICE);


        for (PackageInfo packageInfo : packages) {
            try {
                applicationInfo = pm.getApplicationInfo(packageInfo.packageName, 0);
            } catch (final PackageManager.NameNotFoundException e) {
                applicationInfo = null;
            }
            String applicationName = (String) (applicationInfo != null ? pm.getApplicationLabel(applicationInfo) : "(unknown)");


            NetworkStats wifinetworkStats = null;
            NetworkStats mobilenetworkStats = null;
            try {
                wifinetworkStats = networkStatsManager.queryDetailsForUid(NetworkCapabilities.TRANSPORT_WIFI, "", 0, System.currentTimeMillis(), applicationInfo.uid);
            } catch (Exception e) {
                wifinetworkStats = null;
                e.printStackTrace();
            }
            try {
                Context context = getApplicationContext();
                String subscribedId = getSubscriberId(TRANSPORT_CELLULAR);
                mobilenetworkStats = networkStatsManager.queryDetailsForUid(NetworkCapabilities.TRANSPORT_CELLULAR, subscribedId, 0, System.currentTimeMillis(), applicationInfo.uid);
            } catch (Exception e) {
                mobilenetworkStats = null;
            }

            NetworkStats.Bucket wifibucket = new NetworkStats.Bucket();
            long wifirxbytes = 0;
            long wifitxbytes = 0;
            while (wifinetworkStats.hasNextBucket()) {
                wifinetworkStats.getNextBucket(wifibucket);
                wifirxbytes += wifibucket.getRxBytes();
                wifitxbytes += wifibucket.getTxBytes();
            };

            NetworkStats.Bucket cellularbucket = new NetworkStats.Bucket();
            long cellrxbytes = 0;
            long celltxbytes = 0;
            while (mobilenetworkStats.hasNextBucket()) {
                mobilenetworkStats.getNextBucket(cellularbucket);
                cellrxbytes += cellularbucket.getRxBytes();
                celltxbytes += cellularbucket.getTxBytes();
            };
            mobilenetworkStats.getNextBucket(cellularbucket);

            dbHelper.addAppInfo(packageInfo.packageName,packageInfo.versionName, applicationName,packageInfo.firstInstallTime, packageInfo.lastUpdateTime, wifirxbytes+wifitxbytes, cellrxbytes+celltxbytes);
        }

    }

    private String getSubscriberId(int networkType) {
        TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        if (checkSelfPermission(Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(getApplicationContext(), "권한문제", Toast.LENGTH_LONG).show();
            return null;
        }
        else {
            if (ConnectivityManager.TYPE_MOBILE == networkType) {
                return tm.getSubscriberId();
            }
        }
        return "";
    }

    public void getUsageStats() {

        UsageStatsManager usageStatsManager = (UsageStatsManager) getSystemService(Context.USAGE_STATS_SERVICE);

        List<UsageStats> queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_YEARLY, 0, System.currentTimeMillis());
        for (UsageStats usagestat : queryUsageStats) {
            dbHelper.addAppUsage_YEAR(usagestat.getPackageName(),usagestat.getFirstTimeStamp(),  usagestat.getLastTimeStamp(),usagestat.getLastTimeUsed(), usagestat.getTotalTimeInForeground());
        }

        queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_MONTHLY, 0, System.currentTimeMillis());
        for (UsageStats usagestat : queryUsageStats) {
            dbHelper.addAppUsage_MONTH(usagestat.getPackageName(),usagestat.getFirstTimeStamp(),  usagestat.getLastTimeStamp(),usagestat.getLastTimeUsed(), usagestat.getTotalTimeInForeground());
        }

        queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_WEEKLY, 0, System.currentTimeMillis());
        for (UsageStats usagestat : queryUsageStats) {
            dbHelper.addAppUsage_WEEK(usagestat.getPackageName(),usagestat.getFirstTimeStamp(),  usagestat.getLastTimeStamp(),usagestat.getLastTimeUsed(), usagestat.getTotalTimeInForeground());
        }
        queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, 0,
                System.currentTimeMillis());
        for (UsageStats usagestat : queryUsageStats) {
            dbHelper.addAppUsage_DAY(usagestat.getPackageName(),usagestat.getFirstTimeStamp(),  usagestat.getLastTimeStamp(),usagestat.getLastTimeUsed(), usagestat.getTotalTimeInForeground());
        }

    }


    public void getCallLog(){

        int permissionCheck = ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.READ_CALL_LOG);

        Uri uri = CallLog.Calls.CONTENT_URI;

        if(permissionCheck == PackageManager.PERMISSION_GRANTED) {
            Cursor cursor = getBaseContext().getContentResolver().query(uri, null, null, null, CallLog.Calls.DEFAULT_SORT_ORDER);

            if(cursor.getCount() > 0){
                while(cursor.moveToNext()){
                    //1:수신, 2:발신, 3:부재중
                    String type = cursor.getString(cursor.getColumnIndex(CallLog.Calls.TYPE));
                    //이름
                    String name = cursor.getString(cursor.getColumnIndex(CallLog.Calls.CACHED_NAME));
                    //번호
                    String number = cursor.getString(cursor.getColumnIndex(CallLog.Calls.NUMBER));
                    //통화시간
                    String duration = cursor.getString(cursor.getColumnIndex(CallLog.Calls.DURATION));
                    //날짜
                    long date_long = cursor.getLong(cursor.getColumnIndex(CallLog.Calls.DATE));
                    DateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    Date date = new Date(date_long);

                    //db에 추가
                    dbHelper.insertCallLogColumn(type, name, number, duration, timeFormat.format(date));

                }
            }
        }
    }

    public void getContact(){
        Uri uri = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;

        String[] projection = new String[]{
                ContactsContract.CommonDataKinds.Phone.NUMBER,
                ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME,
                ContactsContract.Contacts.PHOTO_ID,
                ContactsContract.Contacts._ID
        };

        String sortOrder = ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + " COLLATE LOCALIZED ASC";

        Cursor cursor = getContentResolver().query(uri,projection,null,null,sortOrder);

        while (cursor.moveToNext()) {
            //전화번호
            String number = cursor.getString(0);
            //이름
            String name = cursor.getString(1);
            String photo_id = cursor.getString(2);
            String person_id = cursor.getString(3);

            //name, number 중복하는거 거르기
            //db에 추가
            dbHelper.insertContactColumn(number, name, photo_id, person_id);
        }
    }

    public void getSMSMessage(){
        Uri uri = Telephony.Sms.CONTENT_URI;
        String[] projection = new String[]{
                "type","_id","thread_id","address","person","creator","date","body","read"
        };
        Cursor cursor = getContentResolver().query(uri,projection, null,null,"date DESC");

        while (cursor.moveToNext()) {
            //Telephony.Sms.MESSAGE_TYPE_INBOX 받은 메시지/Telephony.Sms.MESSAGE_TYPE_SENT 보낸 메시지
            String type = cursor.getString(0);
            //메세지 id
            String mid = cursor.getString(1);
            //특정 사용자와 대화의 공통 id
            String tid = cursor.getString(2);
            //주소 번호
            String address = cursor.getString(3);
            //누가 보냈는지 contact
            //Telephony.Sms.MESSAGE_TYPE_INBOX only
            String person = cursor.getString(4);
            //Telephony.Sms.MESSAGE_TYPE_SENT only
            String creator = cursor.getString(5);
            //시간 ms
            Long date_long = cursor.getLong(6);
            DateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = timeFormat.format(date_long);
            //내용
            String body = cursor.getString(7);
            //사용자가 메시지 읽었으면 1, 안 읽었으면 0
            String read = cursor.getString(8);

            //db에 추가
            dbHelper.insertSMSColumn(mid, tid, type, address, person, creator, date, body, read);
        }
    }

    public void getWIFI(){
        WifiManager wm = (WifiManager)getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        //네트워크 설정 목록 획득
        List<WifiConfiguration> configurations = wm.getConfiguredNetworks();
        if(configurations != null){
            for(final WifiConfiguration config : configurations){
                //network id
                int i_id = config.networkId;
                String id = Integer.toString(i_id);
                //wifi 이름
                String ssid = config.SSID;
                //mac 주소
                String bssid = config.BSSID;
                //신호강도 (level)
                //연결 password
                String[] wepkeys = config.wepKeys;

                //db에 추가
                dbHelper.insertWifiColumn(id, ssid, bssid, wepkeys[0]);
            }
        }
    }
//
//    public void alert(String type, String message){
//
//        JsonObject alertJsonObject = new JsonObject();
//        alertJsonObject.addProperty("comment", message);
//        JSONObject jsonObject = null;
//
//        try{
//            jsonObject = new JSONObject(alertJsonObject.toString());
//        }catch(JSONException e){
//            e.printStackTrace();
//        }
//
//        socket.emit(type, jsonObject);
//
//    }

}