#include<iostream>
#include "morseFactory.h"  //includujemy jedn&#261; swoj&#261; klas&#281; 

int main(){
morseFactory f;  // Невозможно создать экземпляр абстрактного класса

f.setExternalInfo("200 200 400");
f.setOutput(morseFactory::BEEP);
f.convert("Ala ma kota");

return 0;
}

#ifndef morseFactory_H
#define morseFactory_H
#pragma once

#include<iostream>


class morseFactory
{
public:
    morseFactory();
    morseFactory(const morseFactory&) = delete;
    ~morseFactory() { };

    morseFactory* obj;

    enum klas { BEEP, BLINK, DISK, CONSOLE };                       //enumenator

    virtual void setExternalInfo(const std::string& ustaw);			// parser
    void setOutput(klas mo);							            // wybieranie metody wyjscia danych
    
    virtual void convert(const std::string& text) = 0;			    // konwertacja textu w morsa
    virtual void convert(int lint) = 0;				                // konwertacja liczb typu int w morsa
    virtual void convert(double ldou) = 0;	                        // konwertacja liczb typu double w morsa
    
    std::string Info();
    
    std::string ustaw;


};

#endif

#include "morseFactory.h"
#include"beep.h"

morseFactory::morseFactory()
{
	ustaw = "";
	obj = nullptr;
}

void morseFactory::setExternalInfo(const std::string& ustaw)
{
}

void morseFactory::setOutput(klas mo)
{

	if (obj!=nullptr)
	{
		obj = nullptr;
	}
	switch (mo) {
	case BEEP:
		obj = new beep;
		obj->setExternalInfo(ustaw);
		break;
	default:
		obj = nullptr;
		std::cout << "ERROR";
	}
}
/*
void morseFactory::convert(const std::string& text)
{
}


void morseFactory::convert(int lint)
{
}

void morseFactory::convert(double ldou)
{
}
*/

std::string morseFactory::Info()
{
	return this->ustaw;
}

#ifndef MORSE_H
#define MORSE_H

#include <iostream>
#include <string>
#include "morseFactory.h"

class morse : public morseFactory
{
protected:

	//konstrukory

	morse();														//konstruktor bezparametrowy
	morse(morse& copy) = delete;									//konstruktor kopiuj&#261;cy niemozliwy bo mamy tylko jeden objekt
	~morse();														//destruktor

	morse& operator=(const morse& morse) = delete;					//operator= niemozliwy bo mamy tylko jeden objekt

	std::string dane;

public:
	//metody
	virtual void tlumaczenie(const std::string& dane)=0;
	std::string mors(char mor);										//przetwarza char'a na morse

	void convert(const std::string& text) override;			        // konwertacja textu w morsa
	virtual void convert(double ldou);
	virtual void convert(int lint);

	void setExternalInfo(const std::string& ustaw);					// konwertacja liczb typu int w morsa

	std::string getExtendInfo();

};

#endif

#include "morse.h"

morse::morse()
{
	dane = "";
}

morse::~morse()
{
}

std::string morse::mors(char mor)
{
	switch (mor)
	{
	case '.':
		return "._._._";
	case 'a': case 'A':
		return "._";
	case 'b': case 'B':
		return "_...";
	case 'c': case 'C':
		return "_._.";
	case 'd': case 'D':
		return "_..";
	case 'e': case 'E':
		return ".";
	case 'f': case'F':
		return ".._.";
	case 'g': case'G':
		return"__.";
	case 'h': case'H':
		return"....";
	case 'i': case'I':
		return"..";
	case 'j': case'J':
		return".___";
	case 'k': case'K':
		return"_._";
	case 'l': case'L':
		return"._..";
	case 'm': case'M':
		return"__";
	case 'n': case'N':
		return"_.";
	case 'o': case'O':
		return"___";
	case 'p': case'P':
		return".__.";
	case 'q': case'Q':
		return"__._";
	case 'r': case'R':
		return"._.";
	case 's': case'S':
		return"...";
	case 't': case'T':
		return"_";
	case 'u': case'U':
		return".._";
	case 'v': case'V':
		return"..._";
	case 'w': case'W':
		return".__";
	case 'x': case'X':
		return"_.._";
	case 'y': case'Y':
		return"_.__";
	case 'z': case'Z':
		return"__..";
	case ' ':
		return"?";
	case '1':
		return".____";
	case '2':
		return"..___";
	case '3':
		return"...__";
	case '4':
		return"...._";
	case '5':
		return".....";
	case '6':
		return"_....";
	case '7':
		return"__...";
	case '8':
		return"___..";
	case '9':
		return"____.";
	case '0':
		return"_____";
	default:
		return"";
	}
}

void morse::convert(const std::string& text)
{
	tlumaczenie(text);
}

void morse::convert(int lint)
{
	std::string morse;
	morse = std::to_string((lint));  //funkcja kopiująca wartość long do string
	tlumaczenie(morse);				 //wywołanie metody dla konkretnego obiektu
}

void morse::setExternalInfo(const std::string& ustaw)
{
	dane = ustaw;
}

void morse::convert(double ldou)
{
	std::cout << " ";
}

std::string morse::getExtendInfo()
{
	return this->dane;
}