#include "wxinc.h"
#include "utils.h"

#ifdef WIN32
#include <shlobj.h>
#include <lm.h>
#endif


wxString GetWindowsProgramDirectory()
{
  //scelta della directory di installazione di default
  #ifdef WIN32
    TCHAR strFolder[MAX_PATH];
    ::SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_CURRENT, strFolder);
    return strFolder;
  #endif
}

wxString GetDefaultDestination()
{
  wxString strDest;
  strDest = GetWindowsProgramDirectory();

  if (strDest.IsEmpty())
  {
    // Forse è la cartella base dove è installato Word?
    wxFileType* pDoc = wxTheMimeTypesManager->GetFileTypeFromExtension(wxT("doc"));
    if (pDoc != NULL)
    {
      wxFileName strFilename = pDoc->GetOpenCommand(wxT("pippo.doc"));
      while (strFilename.GetDirCount() > 1)
        strFilename.RemoveLastDir();
      strDest = strFilename.GetPath().After('"');
      if (strDest.StartsWith(wxT("C\\")))
        strDest = wxT("C:") + strDest.Mid(1);
    }
  }

  return strDest;
}

//Magico metodo per stabilire se una directory e' condivisa ed e' su un disco locale!!
bool IsSharedDirectory (const wxString& strDir)
{
  bool found = false;

  wxString strDataDir = strDir.Lower();
  strDataDir.Replace ("/", "\\");

  NET_API_STATUS res = ERROR_MORE_DATA;
  while (res==ERROR_MORE_DATA && !found)
  {
    PSHARE_INFO_502 shi;
    DWORD nEntriesRead =0, nTotalEntries = 0, nResume = 0;
    res = NetShareEnum(NULL, 502, (LPBYTE *)&shi, -1, &nEntriesRead, &nTotalEntries, &nResume);
    if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
    {
      for (DWORD i = 0; i < nEntriesRead; i++)
      {
/*Oh ignaro programmatore, questa parte commentata utilizza funzioni native di windows che non si sono riuscite..
..a far funzionare! Se osi, prova la tua forza rendendole utili!
//la directory dei dati deve essere leggibile,scrivibile,e filecreabile
        int Result = NetShareGetInfo(NULL, shi[i].shi502_netname, 502, (LPBYTE *)&shi[i]);
        if (shi[i].shi502_permissions & (PERM_FILE_READ | PERM_FILE_WRITE | PERM_FILE_CREATE))*/
        {
          wxString strPath(shi[i].shi502_path);
          strPath.MakeLower();
          //se trova la directory di studio condivisa ed e' su disco locale -> server
          if (strDir.StartsWith(strPath))
          {
            found = true;
            break;
          }
        }
      } //for(DWORD i...
      NetApiBufferFree(shi);
    } //if(res ==...
  } //while (res==ERROR_MORE_DATA...

  return found;
}

//finestre per messaggi vari
//---------------------------------------------------------------------------------
bool ErrorBox(const wxString str)
{
  wxMessageBox(str, APPNAME, wxOK | wxICON_ERROR);
  return false;
}

bool WarningBox(const wxString str)
{
  wxMessageBox(str, APPNAME, wxOK | wxICON_EXCLAMATION);
  return false;
}


//classe per gestire i .Ini di campo
//-----------------------------------------------------------------------------------
  bool CampoIniFile::GetFirstGroup(wxString& strGroup, long& nIndex)
  {
    m_asGroups.Clear();

    char bufferone[1024*16];
    ::GetPrivateProfileSectionNames(bufferone, sizeof(bufferone), m_strIniName);
    const char* inizio = bufferone;
    for (const char* b = bufferone; ; b++) if (*b == '\0')
    {
      if (*inizio)
      {
        m_asGroups.Add(inizio);
        inizio = b+1;
      }
      else
        break;
    }

    nIndex = 0;
    return GetNextGroup(strGroup, nIndex);
  }

  bool CampoIniFile::GetNextGroup(wxString& strGroup, long& nIndex)
  {
    const bool ok = nIndex >= 0 && nIndex < (long)m_asGroups.GetCount();
    if (ok)
      strGroup = m_asGroups[nIndex++];
    return ok;
  }

  bool CampoIniFile::DeleteGroup(const wxString strGroup)
  {
    return WritePrivateProfileString(m_strGroup, NULL, NULL, m_strIniName) != 0;
  }

  bool CampoIniFile::GetFirstEntry(wxString& strEntry, long& nIndex)
  {
    m_asEntries.Clear();

    char bufferone[1024*32];
    ::GetPrivateProfileSection(m_strGroup, bufferone, sizeof(bufferone), m_strIniName);
    const char* pInizio = bufferone;
    for (const char* b = bufferone; ; b++) if (*b == '\0')
    {
      if (*pInizio)
      {
        wxString strWrk = pInizio;
        strWrk = strWrk.BeforeFirst('=');
        strWrk.Trim();
        //prende solo il nome della variabile per completare la lista! dopo l'= ci sarebbe il valore
        m_asEntries.Add(strWrk);
        pInizio = b+1;
      }
      else
        break;
    }

    nIndex = 0;
    return GetNextEntry(strEntry, nIndex);
  }

  bool CampoIniFile::GetNextEntry(wxString& strEntry, long& nIndex)
  {
    const bool ok = nIndex >= 0 && nIndex < (long)m_asEntries.GetCount();
    if (ok)
      strEntry = m_asEntries[nIndex++];
    return ok;
  }

  wxString CampoIniFile::Get(const wxString strVariable) const
  {
    wxString strOutString;
    char* buffer = strOutString.GetWriteBuf(256);
    GetPrivateProfileString(m_strGroup, strVariable, "", buffer, 256, m_strIniName);
    strOutString.UngetWriteBuf(); //sblocca la memoria senno' la stringa resta per sempre!!!

    return strOutString;
  }

  bool CampoIniFile::GetBool(const wxString strVariable) const
  {
    const char chVal = Get(strVariable)[0];
    return chVal == 'X' || chVal == 'Y' || chVal == '1';
  }

  int CampoIniFile::GetInt(const wxString strVariable) const
  {
    return atoi(Get(strVariable)); 
  }

  bool CampoIniFile::Set(const wxString strVariable, const wxString strValue)
  {
    return WritePrivateProfileString(m_strGroup, strVariable, strValue, m_strIniName) != 0;
  }
  
  bool CampoIniFile::Set(const wxString strVariable, const int uValue)
  {
    wxString strValue;
    strValue << uValue;
    return WritePrivateProfileString(m_strGroup, strVariable, strValue, m_strIniName) != 0;
  }

//costruttore
CampoIniFile::CampoIniFile(const wxString strIniPath, wxString strGroup)
            : m_strIniName(strIniPath), m_strGroup(strGroup)
{
}


//metodo per sapere che cavolo di tipo di installazione sta esaminando (serve per leggere e scrivere...
//...correttamente il campo.ini
InstallationType CampoIniFile::GetInstallationType() const
{
  InstallationType nType = (InstallationType)GetInt("Type");
  if (nType < it_standalone || nType > it_client)
  {
    nType = it_standalone;  //di base e' standalone
    const bool bTestDataBase = GetBool("TestDatabase");
    const bool bTestPrograms = GetBool("TestPrograms");
    
    if (bTestDataBase)  //se puo' manipolare i dati e' StandAlone o Server..
    {
      //ma e' Standalone o Server?
      //se la directory dei dati e' condivisa in scrittura e' un server (almeno al 99%)
      const wxString strStudy = Get("Study");
      if (IsSharedDirectory(strStudy))
        nType = it_server;  //e' server
    }
    else                //..senno' e' client
      nType = it_client;
  }
  return nType;
}

//gestione filesystem
//--------------------------------------------------------------------------------------
void CheckAndMakeDir(const wxString& strDir, const wxString& strMsg)
{
  if (!wxDir::Exists(strDir))
  {
    const wxFileName fname(strDir + "\\*.*");
    const wxArrayString& asDirs = fname.GetDirs();
    wxString strCartella = fname.GetVolume();
    strCartella += fname.GetVolumeSeparator();
    for (size_t i = 0; i < asDirs.GetCount(); i++)
    {
      strCartella += "\\";
      strCartella += asDirs[i];
      if (!wxDir::Exists(strCartella) && !wxMkdir(strCartella))
      {  
        wxString strError = "Impossibile creare la cartella ";
        strError += strMsg;
        strError += " ";
        strError += strCartella;
        strError += "\nAssicurarsi di avere il permesso di scrittura sul disco e che vi sia spazio a sufficienza";
        ErrorBox(strMsg);
        return;
      }
    }
  }
  if (!strMsg.IsEmpty())  //se il messaggio e' vuoto NON deve fare alcun controllo (installazione sistema)
  {
    wxDir dirDir(strDir);
    if(dirDir.HasFiles()) //se la dir di destinazione dovesse esistere gia' (installazione abortita) almeno sia vuota
    {
      ErrorBox("La cartella di destinazione non e' vuota!\nInstallazione interrotta!");
      return;
    }
  }
}


//metodi per unzippare i files
//-------------------------------------------------------------------------------
static size_t GetZipList(const char* strZipFile, wxArrayString& aFiles)
{
	wxFFileInputStream fin(strZipFile);
  wxZipInputStream zip(fin);
  for (wxZipEntry* z = zip.GetNextEntry(); z; z = zip.GetNextEntry())
  {
    const wxString str = z->GetInternalName();
    aFiles.Add(str);
  }

	return aFiles.GetCount();
}



bool UnzipFile(const char* strZipFile, const char* strDestDir)
{
	wxArrayString aFiles;
	const size_t files = GetZipList(strZipFile, aFiles);

  wxProgressDialog pi("Unzip", "", (int)files, NULL, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);

	for (unsigned int f = 0; f < files; f++)
	{
    const wxString& strFileName = aFiles[f];
    if (!pi.Update(f, strFileName))
      break;

    if (wxEndsWithPathSeparator(strFileName) || strFileName.Find('.') < 0)  // Is dir name
    {
		  wxString strOutDir = strDestDir;
      if (!wxEndsWithPathSeparator(strOutDir))
		    strOutDir += wxFILE_SEP_PATH;
		  strOutDir += strFileName;
		  if (!::wxDirExists(strOutDir))
			  ::wxMkdir(strOutDir);
    }
    else
    {
		  wxZipInputStream fin(strZipFile, strFileName);

		  wxString strOutFile = strDestDir;
      if (!wxEndsWithPathSeparator(strOutFile) && !wxIsPathSeparator(strFileName[0]))
		    strOutFile += wxFILE_SEP_PATH;
		  strOutFile += strFileName;

		  wxString strPath;
		  ::wxSplitPath(strOutFile, &strPath, NULL, NULL);
      CheckAndMakeDir(strPath, wxEmptyString);
	
      wxFileOutputStream fout(strOutFile);
		  fout.Write(fin);
    }
	}
	return files > 0;
}