// ####ECOSHOSTGPLCOPYRIGHTBEGIN####                                        
// -------------------------------------------                              
// This file is part of the eCos host tools.                                
// Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.            
//
// This program is free software; you can redistribute it and/or modify     
// it under the terms of the GNU General Public License as published by     
// the Free Software Foundation; either version 2 or (at your option) any   
// later version.                                                           
//
// This program is distributed in the hope that it will be useful, but      
// WITHOUT ANY WARRANTY; without even the implied warranty of               
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        
// General Public License for more details.                                 
//
// You should have received a copy of the GNU General Public License        
// along with this program; if not, write to the                            
// Free Software Foundation, Inc., 51 Franklin Street,                      
// Fifth Floor, Boston, MA  02110-1301, USA.                                
// -------------------------------------------                              
// ####ECOSHOSTGPLCOPYRIGHTEND####                                          
// PkgAdminDlg.cpp : implementation file
//

#include "stdafx.h"

#include "PkgAdmin.h"
#include "PkgAdminDlg.h"
#include "PkgAdminLicenseDlg.h"
#include "PkgAdminTclWaitDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CPkgadminAboutDlg dialog used for App About

class CPkgadminAboutDlg : public CDialog
{
public:
	CPkgadminAboutDlg();

// Dialog Data
	//{{AFX_DATA(CPkgadminAboutDlg)
	enum { IDD = IDD_PKGADMIN_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CPkgadminAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CPkgadminAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CPkgadminAboutDlg::CPkgadminAboutDlg() : CDialog(CPkgadminAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CPkgadminAboutDlg)
	//}}AFX_DATA_INIT
}

void CPkgadminAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CPkgadminAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CPkgadminAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CPkgadminAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPkgAdminDlg dialog

CPkgAdminDlg::CPkgAdminDlg(LPCTSTR pszRepository,LPCTSTR pszUserTools)
	: CeCosDialog(CPkgAdminDlg::IDD, NULL)
{
	//{{AFX_DATA_INIT(CPkgAdminDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
  if(pszRepository){
	  m_strRepository=pszRepository;
  }
  if(pszUserTools){
	  m_strUserTools=pszUserTools;
  }
	m_CdlPkgData = NULL;
}

void CPkgAdminDlg::DoDataExchange(CDataExchange* pDX)
{
	CeCosDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CPkgAdminDlg)
	DDX_Control(pDX, IDC_PKGADMIN_REMOVE, m_btnRemove);
	DDX_Control(pDX, IDC_PKGADMIN_TREE, m_ctrlPackageTree);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CPkgAdminDlg, CeCosDialog)
	//{{AFX_MSG_MAP(CPkgAdminDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_PKGADMIN_REMOVE, OnPkgadminRemove)
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_PKGADMIN_ADD, OnPkgadminAdd)
	ON_BN_CLICKED(IDCLOSE, OnClose)
	ON_BN_CLICKED(IDC_PKGADMIN_REPOSITORY, OnPkgadminRepository)
	ON_NOTIFY(TVN_SELCHANGED, IDC_PKGADMIN_TREE, OnSelchangedPkgadminTree)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPkgAdminDlg message handlers

BOOL CPkgAdminDlg::OnInitDialog()
{
	CeCosDialog::OnInitDialog();

  if(this==AfxGetApp()->m_pMainWnd){ // only if the dialog is the application
	  // Add "About..." menu item to system menu.

	  // IDM_ABOUTBOX must be in the system command range.
	  ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	  ASSERT(IDM_ABOUTBOX < 0xF000);

	  CMenu* pSysMenu = GetSystemMenu(FALSE);
	  if (pSysMenu != NULL)
	  {
		  CString strAboutMenu;
		  strAboutMenu.LoadString(IDS_ABOUTBOX);
		  if (!strAboutMenu.IsEmpty())
		  {
			  pSysMenu->AppendMenu(MF_SEPARATOR);
			  pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		  }
	  }

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	  SetIcon(m_hIcon, TRUE);			// Set big icon
	
  // The following AppWizard-generated call was causing the 32x32 icon to
	//  be resized for use as a 16x16 icon. Removing the call causes the
	//  correct 16x16 icon to be displayed.
//	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// TODO: Add extra initialization here

	// setup the repsoitory location

	  if (m_strRepository.IsEmpty()) // if the repository cannot be located
	  {
		  OnPkgadminRepository (); // prompt the user for the repository location
		  if (m_strRepository.IsEmpty ())
		  {
			  PostMessage (WM_COMMAND,IDCANCEL);
			  return TRUE;
		  }
	  }
  } else {
    GetDlgItem(IDC_PKGADMIN_REPOSITORY)->ShowWindow(SW_HIDE);
  }

	// setup the path to the user tools (tar and gunzip)

	if ((! m_strUserTools.IsEmpty()) || FindUserToolsPath ()) // if the user tools can be located
	{
		// add the user tools to the PATH environment variable
		const DWORD nLength = GetEnvironmentVariable (_T("PATH"), NULL, 0) + 1;
		TCHAR * pszOldPath  = new TCHAR [nLength];
		GetEnvironmentVariable (_T("PATH"), pszOldPath, nLength);
		SetEnvironmentVariable (_T("PATH"), CString (pszOldPath) + _T(";") + m_strUserTools);
		delete [] pszOldPath;
	}

	// setup the package tree image list

	m_ilTreeIcons.Create (IDB_PKGADMIN_TREEICONS, 16, 1, RGB (0,128,128));
	m_ctrlPackageTree.SetImageList (&m_ilTreeIcons, TVSIL_NORMAL);

	// populate the package tree

	while (! PopulatePackageTree (m_strRepository))
	{
		m_strRepository = _T("");
		OnPkgadminRepository (); // prompt the user for the repository location
		if (m_strRepository.IsEmpty ()) // if dialog was cancelled
		{
			PostQuitMessage (1);
			return TRUE;
		}
	}
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CPkgAdminDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CPkgadminAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CeCosDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CPkgAdminDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CeCosDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CPkgAdminDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

// Trivial handlers; otherwise CdlPackagesDatabaseBody::make asserts.
void CdlErrorHandler (std::string message)
{
};

void CdlWarningHandler (std::string message)
{
};


bool CPkgAdminDlg::PopulatePackageTree(LPCTSTR pszPackagesPath)
{
	// delete any existing CDL database

	if (m_CdlPkgData)
	{
		delete m_CdlPkgData;
		m_CdlPkgData = NULL;
	}

	// load the package database

	try
	{
        // Cdl asserts unless the handlers are present.
#if 1
        m_CdlPkgData = CdlPackagesDatabaseBody::make (UnicodeToStdStr (pszPackagesPath), &CdlErrorHandler, &CdlWarningHandler);
#else
        m_CdlPkgData = CdlPackagesDatabaseBody::make (UnicodeToStdStr (pszPackagesPath));
#endif
	}
	catch (CdlStringException exception)
	{
		CString strMessage;
		strMessage.Format (_T("Error loading database:\n\n%s"), CString (exception.get_message ().c_str ()));
		AfxMessageBox (strMessage);
		return false;
	}
	catch (...)
	{
		AfxMessageBox (_T("Error loading database"));
		return false;
	}

	// clear the old package tree

	ClearPackageTree ();

	// populate the new package tree

	const std::vector<std::string>& packages = m_CdlPkgData->get_packages ();
	for (std::vector<std::string>::const_iterator package = packages.begin (); package != packages.end (); package++)
	{
		// add a package node

		TRACE (_T("Adding package %s:"), CString (package->c_str ()));
		HTREEITEM hPackage = m_ctrlPackageTree.InsertItem (CString (m_CdlPkgData->get_package_aliases (*package) [0].c_str ()));
		m_ctrlPackageTree.SetItemData (hPackage, (DWORD) new CString (package->c_str ()));
		m_ctrlPackageTree.SetItemImage (hPackage, 0, 0);

		const std::vector<std::string>& versions = m_CdlPkgData->get_package_versions (* package);
		for (std::vector<std::string>::const_iterator version = versions.begin (); version != versions.end (); version++)
		{
			// add a version node

			TRACE (_T(" %s"), CString (version->c_str ()));
			const HTREEITEM hVersion = m_ctrlPackageTree.InsertItem (CString (version->c_str ()), hPackage);
			m_ctrlPackageTree.SetItemImage (hVersion, 1, 1);
		}
		TRACE (_T("\n"));
		m_ctrlPackageTree.SortChildren (hPackage); // sort the version nodes
	}

	m_ctrlPackageTree.SortChildren (NULL); // sort the package nodes

  if(this==AfxGetApp()->m_pMainWnd){ // if the dialog is the application
	  // update the caption bar
	  CString strCaption (m_strRepository);
	  strCaption.Replace (_TCHAR('/'), _TCHAR('\\'));
	  strCaption += _T(" - eCos Package Administration Tool");
	  SetWindowText (strCaption);
  }

	return true;
}

void CPkgAdminDlg::OnPkgadminRemove() 
{
	const HTREEITEM hTreeItem = m_ctrlPackageTree.GetSelectedItem ();
	if (! hTreeItem)
		return;

	if (IDYES != CWnd::MessageBox (_T("The selected package will be deleted from the repository. Core eCos packages may be restored only by reinstalling eCos.\n\nDo you wish to continue?"),
		_T("Remove Package"), MB_YESNO | MB_ICONEXCLAMATION))
		return;

	const CString * pstrPackage = (const CString *) m_ctrlPackageTree.GetItemData (hTreeItem);
	if (pstrPackage) // if a package node is selected
	{
		// remove all package version nodes

		bool bStatus = true;
		HTREEITEM hChildItem = m_ctrlPackageTree.GetChildItem (hTreeItem);
		while (hChildItem && bStatus)
		{
			const HTREEITEM hNextChildItem = m_ctrlPackageTree.GetNextSiblingItem (hChildItem);			
			bStatus = RemovePackageVersion (hChildItem);
			hChildItem = hNextChildItem;
		}

		// remove the package node

		if (bStatus)
		{
			delete pstrPackage;
			m_ctrlPackageTree.DeleteItem (hTreeItem);
		}
	}
	else // a version node is selected
	{
		// remove the version node

		const HTREEITEM hParentItem = m_ctrlPackageTree.GetParentItem (hTreeItem);
		ASSERT (hParentItem);
		if (RemovePackageVersion (hTreeItem) && ! m_ctrlPackageTree.ItemHasChildren (hParentItem)) // if the only version was deleted
		{
			// remove the package node

			delete pstrPackage;
			m_ctrlPackageTree.DeleteItem (hParentItem); 
		}
	}
}

void CPkgAdminDlg::ClearPackageTree()
{
	HTREEITEM hPackage = m_ctrlPackageTree.GetRootItem ();
	if (! hPackage) // if no packages in the tree...
		return;     // ...nothing to do

	while (hPackage)
	{
		const HTREEITEM hNextPackage = m_ctrlPackageTree.GetNextSiblingItem (hPackage);
		TRACE (_T("Deleting package %s\n"), * ((CString *) m_ctrlPackageTree.GetItemData (hPackage)));
		delete (CString *) m_ctrlPackageTree.GetItemData (hPackage);
		m_ctrlPackageTree.DeleteItem (hPackage);
		hPackage = hNextPackage;
	}
}

void CPkgAdminDlg::OnDestroy() 
{
	CeCosDialog::OnDestroy();
	
	// free memory allocated to the tree item data CStrings

	ClearPackageTree ();

	// free memory allocated to the CDL database

	if (m_CdlPkgData)
		delete m_CdlPkgData;

}

void CPkgAdminDlg::OnPkgadminAdd() 
{
	CFileDialog dlg (TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT, _T("eCos Package Files (*.epk)|*.epk||"), GetParent ());
	TCHAR szBuffer [MAX_PATH * 16] = _T("");
	dlg.m_ofn.lpstrFile = szBuffer;
	dlg.m_ofn.nMaxFile = MAX_PATH * 16;
	dlg.m_ofn.lpstrTitle = _T("Open eCos Package Files");
	if (IDOK == dlg.DoModal ())
	{
		bool bRepositoryChanged = false;
		POSITION posPathName = dlg.GetStartPosition ();
		while (posPathName)
		{
			// get an eCos package distribution file

			CString strPathName = dlg.GetNextPathName (posPathName);

			// extract the licence file

			CString strCommand;
			strCommand.Format (_T("add %s --extract_license"), strPathName);
			strCommand.Replace (_TCHAR('\\'), _TCHAR('/')); // backslashes -> forward slashes for Tcl_EvalFile
			EvalTclFile (3, strCommand);
			CString strLicenseFile = m_strRepository + _T("/pkgadd.txt");
			strLicenseFile.Replace (_TCHAR('/'), _TCHAR('\\')); // forward slashes -> backslashes for Win32

			// read the license file

			CFile fileLicenseFile;
			if (fileLicenseFile.Open (strLicenseFile, CFile::modeRead))
			{
				TRACE (_T("License file found at %s\n"), strLicenseFile);
				const DWORD dwLicenseLength = fileLicenseFile.GetLength ();
				char * pszBuffer = new char [dwLicenseLength + 1]; // allocate a buffer
				fileLicenseFile.Read (pszBuffer, dwLicenseLength);
				fileLicenseFile.Close ();
				CFile::Remove (strLicenseFile); // delete the license file when read
				pszBuffer [dwLicenseLength] = NULL; // terminate the string in the buffer
				CString strLicenseText (pszBuffer); // copy into a CString to convert to Unicode
				delete [] pszBuffer;
				if (-1 == strLicenseText.Find (_T("\r\n"))) // if the file has LF line endings...
					strLicenseText.Replace (_T("\n"), _T("\r\n")); // ... replace with CRLF line endings

				// display the license text

				CPkgAdminLicenseDlg dlgLicense (this);
				dlgLicense.m_strLicense = strLicenseText;
				dlgLicense.SetCaption (strPathName + _T(" - Add Packages"));
				if (IDOK != dlgLicense.DoModal ()) // if license not accepted by user
					continue; // try the next file
			}

			// add the contents of the package distribution file

			strCommand.Format (_T("add %s --accept_license"), strPathName);
			strCommand.Replace (_TCHAR('\\'), _TCHAR('/')); // backslashes -> forward slashes for Tcl_EvalFile
			if (! EvalTclFile (3, strCommand))  // if not successful
				continue; // try the next file

			bRepositoryChanged = true;
		}

		// refresh the package tree only if necessary

		if (bRepositoryChanged && ! PopulatePackageTree (m_strRepository))
			DestroyWindow ();
	}
}

bool CPkgAdminDlg::EvalTclFile(int nArgc, LPCTSTR pszArgv)
{
	CPkgAdminTclWaitDlg dlgWait;

	TRACE (_T("Evaluating ecosadmin.tcl %s\n"), pszArgv);

	// set up the data structure which is passed to the Tcl thread

	CString strArgc;
	strArgc.Format (_T("%d"), nArgc);
	std::string argv0 = UnicodeToStdStr (m_strRepository) + "/ecosadmin.tcl";
	std::string argv = UnicodeToStdStr (pszArgv);
	std::string argc = UnicodeToStdStr (strArgc);
	dlgWait.etsInfo.argv0 = (char *) argv0.c_str ();
	dlgWait.etsInfo.argv = (char *) argv.c_str ();
	dlgWait.etsInfo.argc = (char *) argc.c_str ();

	// display the 'please wait' dialog
	// the Tcl command is invoked from CPkgAdminTclWaitDlg::OnCreate()

	CWaitCursor curWait;
	dlgWait.DoModal ();
	curWait.Restore ();

	// retrieve status information from the data structure

	int nStatus = dlgWait.etsInfo.status;
	CString strErrorMessage (dlgWait.etsInfo.result);

	// report any error

	if (! strErrorMessage.IsEmpty ())
	{
		AfxMessageBox (_T("Command execution error:\n\n") + strErrorMessage);
		return false;
	}
	else if (TCL_OK != nStatus)
	{
		AfxMessageBox (_T("Command execution error"));
		return false;
	}

	return true;
}

bool CPkgAdminDlg::RemovePackageVersion(HTREEITEM hTreeItem)
{
	const HTREEITEM hParentItem = m_ctrlPackageTree.GetParentItem (hTreeItem);
	ASSERT (hParentItem);
	CString * pstrPackage = (CString *) m_ctrlPackageTree.GetItemData (hParentItem);
	ASSERT (pstrPackage);
	CString strCommand;
	strCommand.Format (_T("remove %s --version %s"), * pstrPackage, m_ctrlPackageTree.GetItemText (hTreeItem));
	if (! EvalTclFile (3, strCommand)) // if not successful
		return false;
	
	m_ctrlPackageTree.DeleteItem (hTreeItem); // remove the selected item from the tree
	return true;
}

void CPkgAdminDlg::OnPkgadminRepository() 
{
	CFileDialog dlg (TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST, _T("eCos Package Database Files (ecos.db)|ecos.db||"), GetParent ());
	dlg.m_ofn.lpstrTitle = _T("Open eCos Package Database File");

	int nStatus;
	do
	{
		nStatus = dlg.DoModal ();
		if (IDOK == nStatus)
		{
			const CString strPathName = dlg.GetPathName ();
			const int nPathNameIndex = strPathName.ReverseFind (_TCHAR('\\'));
			ASSERT (nPathNameIndex != -1);
			m_strRepository = strPathName.Mid (0, nPathNameIndex);
			m_strRepository.Replace (_TCHAR('\\'), _TCHAR('/'));
		}
	}
	while ((IDOK == nStatus) && ! PopulatePackageTree (m_strRepository));
}

void CPkgAdminDlg::OnSelchangedPkgadminTree(NMHDR*, LRESULT* pResult) 
{
	//NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;

	// enable the remove button only if a node is selected
	m_btnRemove.EnableWindow (NULL != m_ctrlPackageTree.GetSelectedItem ());

	*pResult = 0;
}

std::string CPkgAdminDlg::UnicodeToStdStr(LPCTSTR str)
{
	int nLength = 1 + _tcslen (str);
	char * pszString = new char [nLength];

	#ifdef _UNICODE
	WideCharToMultiByte (CP_ACP, 0, str, -1, pszString, nLength, NULL, NULL);
	#else
	strcpy (pszString, str);
	#endif

	std::string stdstr = std::string (pszString);
	delete [] pszString;
	return stdstr;
}

bool CPkgAdminDlg::FindUserToolsPath()
{
	HKEY hKey;
	if (ERROR_SUCCESS != RegOpenKeyEx (HKEY_CURRENT_USER, _T("Software\\Red Hat\\eCos\\Configuration Tool\\User Tools"), 0, KEY_READ, &hKey))
		return false;
	
	TCHAR szBuffer [MAX_PATH + 1];
	DWORD dwBufferLength = MAX_PATH + 1;
	LONG lStatus = RegQueryValueEx (hKey, _T("Folder"), NULL, NULL, (LPBYTE) szBuffer, &dwBufferLength);
	RegCloseKey (hKey);
	if (ERROR_SUCCESS != lStatus)
		return false;

	m_strUserTools = szBuffer;
	TRACE (_T("User tools found at %s\n"), m_strUserTools);
	return ! m_strUserTools.IsEmpty ();
}
