//main.cpp***********************************************************************************************

#include <conio.h>
#include <iostream>
#include <iomanip>

#include "Capacitor.h"
#include "Resistor.h"
#include "Filter.h"

int main()
{
// Local variable for text data entry
    char tempName[16];
// Local variable for component value data entry
    double tempValue;

    std::cout << "Instantiate one object of class Filter" << std::endl << std::endl;

    std::cout << "Enter a name for the new filter object:  ";
    std::cin.getline (tempName, 15, '\n');

    Filter filt1;

// Display filter values
    std::cout << setiosflags (std::ios::fixed)
         << setiosflags (std::ios::right)
         << setiosflags (std::ios::showpoint)
         << std::setprecision (3);
    std::cout << std::endl << std::endl;
    std::cout << "Nominal Filter Frequency =   " << std::setw (10) << filt1.getFilter() << " Hertz" << std::endl;
    std::cout << "Minimum Filter Frequency =   " << std::setw (10) << filt1.getMaxFilter() << " Hertz" << std::endl;
    std::cout << "Maximum Filter Frequency =   " << std::setw (10) << filt1.getMinFilter() << " Hertz" << std::endl;
    std::cout << "Filter Bandwidth Frequency = " << std::setw (10) << filt1.getFilterTol() << " Hertz" << std::endl;

// Display resistor values
    std::cout << std::setiosflags (std::ios::fixed)
         << std::setiosflags (std::ios::right)
         << std::setiosflags (std::ios::showpoint)
         << std::setprecision (3);
    std::cout << std::endl << std::endl;
    std::cout << "Nominal Resistance Value =   " << std::setw (10) << filt1.getResistance() << " ohms" << std::endl;
    std::cout << "Resistor Tolerance Value =   " << std::setw (10) << filt1.getResTolerance() * 100 << " Percent" << std::endl;
    std::cout << "Maximum Resistance Value =   " << std::setw (10) << filt1.getMaxResistance() << " ohms" << std::endl;
    std::cout << "Minimum Resistance Value =   " << std::setw (10) << filt1.getMinResistance() << " ohms" << std::endl;
    std::cout << std::endl << std::endl;

// Display capacitor values
    std::cout << std::setiosflags (std::ios::fixed)
         << std::setiosflags (std::ios::showpoint)
         << std::setiosflags (std::ios::left)
         << std::setprecision (3);
    std::cout << "Nominal Capacitance Value =  " << std::setw (10) << filt1.getCapacitance() * 1000000 << " micro Farads" << std::endl;
    std::cout << "Capacitor Tolerance Value =  " << std::setw (10) << filt1.getCapTolerance() * 100 << " Percent" << std::endl;
    std::cout << "Maximum Capacitance Value =  " << std::setw (10) << filt1.getMaxCapacitance() * 1000000 << " micro Farads" << std::endl;
    std::cout << "Minimum Capacitance Value =  " << std::setw (10) << filt1.getMinCapacitance() * 1000000 << " micro Farads" << std::endl;
    std::cout << std::endl << std::endl;

//filt1.FilterSave();

    std::cout << "Enter new nominal resistance value for filter:  ";
    std::cin >> tempValue;
    filt1.setResistance (tempValue);

    std::cout << "Enter new resistance tolerance value for filter:  ";
    std::cin >> tempValue;
    filt1.setResTolerance (tempValue / 100.0);

    std::cout << "Enter new nominal micro Farad capacitance value for filter:  ";
    std::cin >> tempValue;
    filt1.setCapacitance (tempValue / 1000000.0);

    std::cout << "Enter new capacitance tolerance value for filter:  ";
    std::cin >> tempValue;
    filt1.setResTolerance (tempValue / 100.0);

// Calculate filter values based on new resistance and capacitance values
    filt1.calculateFilter();

// Display filter values
    std::cout << std::setiosflags (std::ios::fixed)
         << std::setiosflags (std::ios::right)
         << std::setiosflags (std::ios::showpoint)
         << std::setprecision (3);
    std::cout << std::endl << std::endl;
    std::cout << "Nominal Filter Frequency =   " << std::setw (10) << filt1.getFilter() << " Hertz" << std::endl;
    std::cout << "Minimum Filter Frequency =   " << std::setw (10) << filt1.getMaxFilter() << " Hertz" << std::endl;
    std::cout << "Maximum Filter Frequency =   " << std::setw (10) << filt1.getMinFilter() << " Hertz" << std::endl;
    std::cout << "Filter Bandwidth Frequency = " << std::setw (10) << filt1.getFilterTol() << " Hertz" << std::endl;

// Display resistor values
    std::cout << std::setiosflags (std::ios::fixed)
         << std::resetiosflags (std::ios::left)
         << std::setiosflags (std::ios::right)
         << std::setiosflags (std::ios::showpoint)
         << std::setprecision (3);
    std::cout << std::endl << std::endl;
    std::cout << "Nominal Resistance Value =   " << std::setw (10) << filt1.getResistance() << " ohms" << std::endl;
    std::cout << "Resistor Tolerance Value =   " << std::setw (10) << filt1.getResTolerance() * 100 << " Percent" << std::endl;
    std::cout << "Maximum Resistance Value =   " << std::setw (10) << filt1.getMaxResistance() << " ohms" << std::endl;
    std::cout << "Minimum Resistance Value =   " << std::setw (10) << filt1.getMinResistance() << " ohms" << std::endl;
    std::cout << std::endl << std::endl;

    std::cout << std::setiosflags (std::ios::fixed)
         << std::setiosflags (std::ios::showpoint)
         << std::setiosflags (std::ios::left)
         << std::setprecision (3);
    std::cout << "Nominal Capacitance Value =  " << std::setw (10) << filt1.getCapacitance() * 1000000 << " micro Farads" << std::endl;
    std::cout << "Capacitor Tolerance Value =  " << std::setw (10) << filt1.getCapTolerance() * 100 << " Percent" << std::endl;
    std::cout << "Maximum Capacitance Value =  " << std::setw (10) << filt1.getMaxCapacitance() * 1000000 << " micro Farads" << std::endl;
    std::cout << "Minimum Capacitance Value =  " << std::setw (10) << filt1.getMinCapacitance() * 1000000 << " micro Farads" << std::endl;
    std::cout << std::endl << std::endl;


    filt1.FilterRead("filenamehere.txt");
}

//Filter.h***********************************************************************************************
#ifndef FILTER_H
#define FILTER_H

#include "Capacitor.h"
#include "Resistor.h"
#include <fstream>

class Filter
{
private:
    Resistor resistor;
    Capacitor capacitor;
    double filterTol;
    double maxFilter;
    double minFilter;
    double resistance;
    double resTol;
    double capacitance;
    double cutOffFrequency;
    double maxFrequency;
    double minFrequency;
    std::string filterType;
public:
Filter();
    void getResistor();
    void getCapacitor();
    void getFilterType();
    void calculateFilter();
    double getFilter();
    double getMaxFilter();
    double getMinFilter();
    double getMaxResistance();
    double getMinResistance();
    double getFilterTol();
    double getResTolerance();
    double getCapacitance();
    double getCapTolerance();
    double getMinCapacitance();
    double getMaxCapacitance();
    double getResistance();
    void setResistance(double);
    void setResTolerance(double);
    void setCapacitance(double);
    void writeToFile();
    void FilterRead (std::string);
};
#endif

//Filter.cpp*********************************************************************************************


#include "Filter.h"

#include <iostream>
#include "Capacitor.h"
#include "Resistor.h"
#include <fstream>


const double PI = 3.141592654;

Filter::Filter()
{
    std::cout << "D:" << std::endl;
}

void Filter::getResistor()
{
    double res;
    double tol;
    std::cout << std::endl << "Enter resistor's resistance:  ";
    std::cin >> res;
    std::cout << std::endl << "Enter resistor tolerance : ";
    std::cin >> tol;
    resistor.setResistance (res);
    resistor.setResTolerance (tol);
}

void Filter::getCapacitor()
{
    double cap;
    double tol;
    std::cout << std::endl << "Enter capacitor capacitance:  ";
    std::cin >> cap;
    std::cout << std::endl << "Enter capacitor tolerance : ";
    std::cin >> tol;
    capacitor.setCapacitance (cap);
    capacitor.setCapTolerance (tol);
}
void Filter::getFilterType()
{
    std::string type;
    std::cout << std::endl << "Enter Filter type(Low, High) : ";
    std::cin >> type;
    filterType = type;
}

void Filter::calculateFilter()
{
    cutOffFrequency = 1 / (2 * 3.14 * (resistor.getResistance() * capacitor.getCapacitance()));
    maxFrequency = 1 / (2 * 3.14 * (resistor.getResistance() + resistor.getResTolerance()) * (capacitor.getCapacitance() + capacitor.getCapTolerance()));
    minFrequency = 1 / (2 * 3.14 * (resistor.getResistance() - resistor.getResTolerance()) * (capacitor.getCapacitance() - capacitor.getCapTolerance()));
}

double Filter::getFilter()
{
    return cutOffFrequency;
}

double Filter::getMaxFilter()
{
    return maxFilter;
}

double Filter::getMinFilter()
{
    return minFilter;
}

double Filter::getResTolerance()
{
    return resTol;
}

double Filter::getMaxResistance()
{
    return resistor.getMaxResistance();
}

double Filter::getMinResistance()
{
    return resistor.getMinResistance();
}

double Filter::getFilterTol()
{
    return filterTol;
}

double Filter::getResistance()
{
    return resistance;
}

double Filter::getCapacitance()
{
    return capacitor.getCapacitance();
}

double Filter::getCapTolerance()
{
    return capacitor.getCapTolerance();
}

double Filter::getMinCapacitance()
{
    return capacitor.getMinCapacitance();
}

double Filter::getMaxCapacitance()
{
    return capacitor.getMaxCapacitance();
}

void Filter::setResistance(double res)
{
    resistance = res;
}

void Filter::setResTolerance(double rest)
{
    resTol = rest;
}

void Filter::setCapacitance(double cap)
{
    capacitance = cap;
}

void Filter::writeToFile()
{
    std::string filename;
    std::cout << "Enter file name: ";
    std::cin >> filename;

    std::ofstream fout;

    fout.open (filename);

    fout << "Resistor resistance: " << resistor.getResistance();
    fout << std::endl << "Resistor tolerance: " << resistor.getResTolerance();
    fout << std::endl << "Resistor Min resistance: " << resistor.getMinResistance();
    fout << std::endl << "Resistor Max resistance: " << resistor.getMaxResistance();
    fout << std::endl << "Capacitor capacitance: " << capacitor.getCapacitance();
    fout << std::endl << "Capacitor tolerance: " << capacitor.getCapTolerance();
    fout << std::endl << "Capacitor max capacitance: " << capacitor.getMaxCapacitance();
    fout << std::endl << "Capacitor min capacitance: " << capacitor.getMinCapacitance();
    fout << std::endl << "Cut off frequency: " << cutOffFrequency;
    fout << std::endl << "Max frequency: " << maxFrequency;
    fout << std::endl << "Min frequency: " << minFrequency;
    fout << std::endl << "Filter Type: " << filterType;
    fout.close();
}

void Filter::FilterRead (std::string filename)
{
    std::ifstream fin;
    fin.open (filename);

    if (!fin)
    {
        std::cout << "File do not exist.";
        return;
    }
    else
    {
        std::string line;

        while (fin)
        {
            getline (fin, line);
            std::cout << line << std::endl;
        }
    }

    fin.close();
}

//Resistor.h*********************************************************************************************

//The Class Declaration
#ifndef RESISTOR_H
#define RESISTOR_H

#include <string>

class Resistor
{

private:
    double m_dResValue;
    double m_dTolerance;
    double m_dMinRResistance;
    double m_dMaxResistance;
protected:
    double resValues[4];
public:
    Resistor (std::string Name, double resistorValue, double resistorTolerance);
    Resistor (const Resistor &resistorObject);
    std::string m_cResistorName;
    void DisplayResistor (void);
    void EnterResistance (void);
    // Returns minimum  tolerance resistance
    double getMinResistance (void);
    // Set FiltRes nominal resistance
    void setResistance (double);
    void setResTolerance (double);
    Resistor (double nom = 1000.0, double tol = 0.10);
    ~Resistor();
    // Returns resistance value
    double getResistance (void);
    // Returns maximum tolerance resistance
    double getMaxResistance (void);
    // Returns resistor tolerance
    double getResTolerance (void);

};
#endif

//Resistor.cpp*******************************************************************************************

#include "Resistor.h"

Resistor::~Resistor()
{
}

Resistor::Resistor (double nom, double tol)
{
    resValues[0] = nom;
    resValues[1] = tol;
    resValues[2] = nom * (1.0 + tol);
    resValues[3] = nom * (1.0 - tol);
}

void Resistor::setResistance (double newResistance)
{
    resValues[0] = newResistance;
    resValues[2] = resValues[0] * (1.0 - resValues[1]);
    resValues[3] = resValues[0] * (1.0 + resValues[1]);
}

void Resistor::setResTolerance (double newResTolerance)
{
    resValues[1] = newResTolerance;
    resValues[2] = resValues[0] * (1.0 - resValues[1]);
    resValues[3] = resValues[0] * (1.0 + resValues[1]);
}

// Returns resistance value
double Resistor::getResistance (void)
{
    return resValues[0];
}

// Returns minimum  tolerance resistance
double Resistor::getMinResistance (void)
{
    return resValues[3];
}

// Returns maximum tolerance resistance
double Resistor::getMaxResistance (void)
{
    return resValues[2];
}

// Returns resistor tolerance
double Resistor::getResTolerance (void)
{
    return resValues[1];
}

//Capacitor.h********************************************************************************************


#ifndef CAPACITOR_H
#define CAPACITOR_H
class Capacitor
{
public:
    // Returns capacitance value
    double getCapacitance (void);
    // Returns minimum tolerance capacitance
    double getMinCapacitance (void);
    // Returns max tolerance capacitance
    double getMaxCapacitance (void);
    // Returns capacitor tolerance
    double getCapTolerance (void);
    double getFilter;
    double getMinFilter();
    double getMaxFilter();
    double getFilterTol();
    void calculateFilter();
    int FilterRead (void);
    void setCapacitance (double);
    void setCapTolerance (double);
    Capacitor (double nom = 0.000001, double tol = 0.20);
    ~Capacitor();


private:
    double capValues[4];

};
#endif

//Capacitor.cpp******************************************************************************************


#include "Capacitor.h"

Capacitor::Capacitor (double nom, double tol)
{
    capValues[0] = nom;
    capValues[1] = tol;
    capValues[2] = nom * (1.0 + tol);
    capValues[3] = nom * (1.0 - tol);
}

Capacitor::~Capacitor()
{
}

void Capacitor::setCapacitance (double newCapacitance)
{
    capValues[0] = newCapacitance;
    capValues[2] = capValues[0] * (1.0 + capValues[1]);
    capValues[3] = capValues[0] * (1.0 - capValues[1]);
}

void Capacitor::setCapTolerance (double newCapTolerance)
{
    capValues[1] = newCapTolerance;
    capValues[2] = capValues[0] * (1.0 + capValues[1]);
    capValues[3] = capValues[0] * (1.0 - capValues[1]);
}

// Returns capacitance value
double Capacitor::getCapacitance (void)
{
    return capValues[0];
}

// Returns minimum tolerance capacitance
double Capacitor::getMinCapacitance (void)
{
    return capValues[3];
}

// Returns max tolerance capacitance
double Capacitor::getMaxCapacitance (void)
{
    return capValues[2];
}

// Returns capacitor tolerance
double Capacitor::getCapTolerance (void)
{
    return capValues[1];
}

//D:\Programming\C++\Projects\CPP\Resistor\Capacitor.cpp||In constructor 'Capacitor::Capacitor(double, double)':|
//D:\Programming\C++\Projects\CPP\Resistor\Capacitor.cpp|3|warning: 'Capacitor::getFilter' should be initialized in the member initialization list|
//obj\Debug\Filter.o:D:\Programming\C++\Projects\CPP\Resistor\Filter.cpp|137|undefined reference to `std::basic_ofstream<char, std::char_traits<char> >::open(std::string const&, std::_Ios_Openmode)'|
//obj\Debug\Filter.o:D:\Programming\C++\Projects\CPP\Resistor\Filter.cpp|157|undefined reference to `std::basic_ifstream<char, std::char_traits<char> >::open(std::string const&, std::_Ios_Openmode)'|
//||=== Build finished: 2 errors, 1 warnings ===|

//I have no idea how you can get an undefined reference to an std library function